Merge branch 'master' into rebased

37 files changed, 5406 insertions, 2447 deletions

diff --git a/src/all_types.hpp b/src/all_types.hpp
index 92faad1e03..ecc0d1a9bb 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -55,7 +55,7 @@ struct IrExecutable {
     size_t mem_slot_count;
     size_t next_debug_id;
     size_t *backward_branch_count;
-    size_t backward_branch_quota;
+    size_t *backward_branch_quota;
     ZigFn *fn_entry;
     Buf *c_import_buf;
     AstNode *source_node;
@@ -1350,6 +1350,7 @@ struct ZigFn {
     IrExecutable ir_executable;
     IrExecutable analyzed_executable;
     size_t prealloc_bbc;
+    size_t prealloc_backward_branch_quota;
     AstNode **param_source_nodes;
     Buf **param_names;
 
@@ -1855,10 +1856,13 @@ struct CodeGen {
     bool strip_debug_symbols;
     bool is_test_build;
     bool is_single_threaded;
+    bool want_single_threaded;
     bool linker_rdynamic;
     bool each_lib_rpath;
     bool is_dummy_so;
     bool disable_gen_h;
+    bool bundle_compiler_rt;
+    bool disable_stack_probing;
 
     Buf *mmacosx_version_min;
     Buf *mios_version_min;
@@ -2291,6 +2295,7 @@ enum IrInstructionId {
     IrInstructionIdVectorToArray,
     IrInstructionIdArrayToVector,
     IrInstructionIdAssertZero,
+    IrInstructionIdAssertNonNull,
 };
 
 struct IrInstruction {
@@ -3480,6 +3485,12 @@ struct IrInstructionAssertZero {
     IrInstruction *target;
 };
 
+struct IrInstructionAssertNonNull {
+    IrInstruction base;
+
+    IrInstruction *target;
+};
+
 static const size_t slice_ptr_index = 0;
 static const size_t slice_len_index = 1;
 
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 394364c68f..57244aba6a 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -969,8 +969,9 @@ static ConstExprValue *analyze_const_value(CodeGen *g, Scope *scope, AstNode *no
         Buf *type_name)
 {
     size_t backward_branch_count = 0;
+    size_t backward_branch_quota = default_backward_branch_quota;
     return ir_eval_const_value(g, scope, node, type_entry,
-            &backward_branch_count, default_backward_branch_quota,
+            &backward_branch_count, &backward_branch_quota,
             nullptr, nullptr, node, type_name, nullptr, nullptr);
 }
 
@@ -1907,6 +1908,18 @@ static Error resolve_union_type(CodeGen *g, ZigType *union_type) {
     return ErrorNone;
 }
 
+static bool type_is_valid_extern_enum_tag(CodeGen *g, ZigType *ty) {
+    // Only integer types are allowed by the C ABI
+    if(ty->id != ZigTypeIdInt)
+        return false;
+
+    // According to the ANSI C standard the enumeration type should be either a
+    // signed char, a signed integer or an unsigned one. But GCC/Clang allow
+    // other integral types as a compiler extension so let's accomodate them
+    // aswell.
+    return type_allowed_in_extern(g, ty);
+}
+
 static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
     assert(enum_type->id == ZigTypeIdEnum);
 
@@ -1964,7 +1977,6 @@ static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
     enum_type->abi_size = tag_int_type->abi_size;
     enum_type->abi_align = tag_int_type->abi_align;
 
-    // TODO: Are extern enums allowed to have an init_arg_expr?
     if (decl_node->data.container_decl.init_arg_expr != nullptr) {
         ZigType *wanted_tag_int_type = analyze_type_expr(g, scope, decl_node->data.container_decl.init_arg_expr);
         if (type_is_invalid(wanted_tag_int_type)) {
@@ -1973,24 +1985,29 @@ static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
             enum_type->data.enumeration.is_invalid = true;
             add_node_error(g, decl_node->data.container_decl.init_arg_expr,
                 buf_sprintf("expected integer, found '%s'", buf_ptr(&wanted_tag_int_type->name)));
-        } else if (wanted_tag_int_type->data.integral.is_signed) {
-            enum_type->data.enumeration.is_invalid = true;
-            add_node_error(g, decl_node->data.container_decl.init_arg_expr,
-                buf_sprintf("expected unsigned integer, found '%s'", buf_ptr(&wanted_tag_int_type->name)));
-        } else if (wanted_tag_int_type->data.integral.bit_count < tag_int_type->data.integral.bit_count) {
+        } else if (enum_type->data.enumeration.layout == ContainerLayoutExtern &&
+                   !type_is_valid_extern_enum_tag(g, wanted_tag_int_type)) {
             enum_type->data.enumeration.is_invalid = true;
-            add_node_error(g, decl_node->data.container_decl.init_arg_expr,
-                buf_sprintf("'%s' too small to hold all bits; must be at least '%s'",
-                    buf_ptr(&wanted_tag_int_type->name), buf_ptr(&tag_int_type->name)));
+            ErrorMsg *msg = add_node_error(g, decl_node->data.container_decl.init_arg_expr,
+                buf_sprintf("'%s' is not a valid tag type for an extern enum",
+                            buf_ptr(&wanted_tag_int_type->name)));
+            add_error_note(g, msg, decl_node->data.container_decl.init_arg_expr,
+                buf_sprintf("any integral type of size 8, 16, 32, 64 or 128 bit is valid"));
         } else {
             tag_int_type = wanted_tag_int_type;
         }
     }
+
     enum_type->data.enumeration.tag_int_type = tag_int_type;
     enum_type->size_in_bits = tag_int_type->size_in_bits;
     enum_type->abi_size = tag_int_type->abi_size;
     enum_type->abi_align = tag_int_type->abi_align;
 
+    BigInt bi_one;
+    bigint_init_unsigned(&bi_one, 1);
+
+    TypeEnumField *last_enum_field = nullptr;
+
     for (uint32_t field_i = 0; field_i < field_count; field_i += 1) {
         AstNode *field_node = decl_node->data.container_decl.fields.at(field_i);
         TypeEnumField *type_enum_field = &enum_type->data.enumeration.fields[field_i];
@@ -2016,60 +2033,58 @@ static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
 
         AstNode *tag_value = field_node->data.struct_field.value;
 
-        // In this first pass we resolve explicit tag values.
-        // In a second pass we will fill in the unspecified ones.
         if (tag_value != nullptr) {
+            // A user-specified value is available
             ConstExprValue *result = analyze_const_value(g, scope, tag_value, tag_int_type, nullptr);
             if (type_is_invalid(result->type)) {
                 enum_type->data.enumeration.is_invalid = true;
                 continue;
             }
+
             assert(result->special != ConstValSpecialRuntime);
-            assert(result->type->id == ZigTypeIdInt ||
-                   result->type->id == ZigTypeIdComptimeInt);
-            auto entry = occupied_tag_values.put_unique(result->data.x_bigint, tag_value);
-            if (entry == nullptr) {
-                bigint_init_bigint(&type_enum_field->value, &result->data.x_bigint);
+            assert(result->type->id == ZigTypeIdInt || result->type->id == ZigTypeIdComptimeInt);
+
+            bigint_init_bigint(&type_enum_field->value, &result->data.x_bigint);
+        } else {
+            // No value was explicitly specified: allocate the last value + 1
+            // or, if this is the first element, zero
+            if (last_enum_field != nullptr) {
+                bigint_add(&type_enum_field->value, &last_enum_field->value, &bi_one);
             } else {
-                Buf *val_buf = buf_alloc();
-                bigint_append_buf(val_buf, &result->data.x_bigint, 10);
+                bigint_init_unsigned(&type_enum_field->value, 0);
+            }
 
-                ErrorMsg *msg = add_node_error(g, tag_value,
-                        buf_sprintf("enum tag value %s already taken", buf_ptr(val_buf)));
-                add_error_note(g, msg, entry->value,
-                        buf_sprintf("other occurrence here"));
+            // Make sure we can represent this number with tag_int_type
+            if (!bigint_fits_in_bits(&type_enum_field->value,
+                                     tag_int_type->size_in_bits,
+                                     tag_int_type->data.integral.is_signed)) {
                 enum_type->data.enumeration.is_invalid = true;
-                continue;
+
+                Buf *val_buf = buf_alloc();
+                bigint_append_buf(val_buf, &type_enum_field->value, 10);
+                add_node_error(g, field_node,
+                    buf_sprintf("enumeration value %s too large for type '%s'",
+                        buf_ptr(val_buf), buf_ptr(&tag_int_type->name)));
+
+                break;
             }
         }
-    }
 
-    // Now iterate again and populate the unspecified tag values
-    uint32_t next_maybe_unoccupied_index = 0;
+        // Make sure the value is unique
+        auto entry = occupied_tag_values.put_unique(type_enum_field->value, field_node);
+        if (entry != nullptr) {
+            enum_type->data.enumeration.is_invalid = true;
 
-    for (uint32_t field_i = 0; field_i < field_count; field_i += 1) {
-        AstNode *field_node = decl_node->data.container_decl.fields.at(field_i);
-        TypeEnumField *type_enum_field = &enum_type->data.enumeration.fields[field_i];
-        AstNode *tag_value = field_node->data.struct_field.value;
+            Buf *val_buf = buf_alloc();
+            bigint_append_buf(val_buf, &type_enum_field->value, 10);
 
-        if (tag_value == nullptr) {
-            if (occupied_tag_values.size() == 0) {
-                bigint_init_unsigned(&type_enum_field->value, next_maybe_unoccupied_index);
-                next_maybe_unoccupied_index += 1;
-            } else {
-                BigInt proposed_value;
-                for (;;) {
-                    bigint_init_unsigned(&proposed_value, next_maybe_unoccupied_index);
-                    next_maybe_unoccupied_index += 1;
-                    auto entry = occupied_tag_values.put_unique(proposed_value, field_node);
-                    if (entry != nullptr) {
-                        continue;
-                    }
-                    break;
-                }
-                bigint_init_bigint(&type_enum_field->value, &proposed_value);
-            }
+            ErrorMsg *msg = add_node_error(g, field_node,
+                    buf_sprintf("enum tag value %s already taken", buf_ptr(val_buf)));
+            add_error_note(g, msg, entry->value,
+                    buf_sprintf("other occurrence here"));
         }
+
+        last_enum_field = type_enum_field;
     }
 
     enum_type->data.enumeration.zero_bits_loop_flag = false;
@@ -2607,7 +2622,7 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
     return ErrorNone;
 }
 
-static void get_fully_qualified_decl_name(Buf *buf, Tld *tld) {
+static void get_fully_qualified_decl_name(Buf *buf, Tld *tld, bool is_test) {
     buf_resize(buf, 0);
 
     Scope *scope = tld->parent_scope;
@@ -2617,15 +2632,23 @@ static void get_fully_qualified_decl_name(Buf *buf, Tld *tld) {
     ScopeDecls *decls_scope = reinterpret_cast<ScopeDecls *>(scope);
     buf_append_buf(buf, &decls_scope->container_type->name);
     if (buf_len(buf) != 0) buf_append_char(buf, NAMESPACE_SEP_CHAR);
-    buf_append_buf(buf, tld->name);
+    if (is_test) {
+        buf_append_str(buf, "test \"");
+        buf_append_buf(buf, tld->name);
+        buf_append_char(buf, '"');
+    } else {
+        buf_append_buf(buf, tld->name);
+    }
 }
 
 ZigFn *create_fn_raw(CodeGen *g, FnInline inline_value) {
     ZigFn *fn_entry = allocate<ZigFn>(1);
 
+    fn_entry->prealloc_backward_branch_quota = default_backward_branch_quota;
+
     fn_entry->codegen = g;
     fn_entry->analyzed_executable.backward_branch_count = &fn_entry->prealloc_bbc;
-    fn_entry->analyzed_executable.backward_branch_quota = default_backward_branch_quota;
+    fn_entry->analyzed_executable.backward_branch_quota = &fn_entry->prealloc_backward_branch_quota;
     fn_entry->analyzed_executable.fn_entry = fn_entry;
     fn_entry->ir_executable.fn_entry = fn_entry;
     fn_entry->fn_inline = inline_value;
@@ -2726,7 +2749,7 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
         if (fn_proto->is_export || is_extern) {
             buf_init_from_buf(&fn_table_entry->symbol_name, tld_fn->base.name);
         } else {
-            get_fully_qualified_decl_name(&fn_table_entry->symbol_name, &tld_fn->base);
+            get_fully_qualified_decl_name(&fn_table_entry->symbol_name, &tld_fn->base, false);
         }
 
         if (fn_proto->is_export) {
@@ -2787,7 +2810,7 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
     } else if (source_node->type == NodeTypeTestDecl) {
         ZigFn *fn_table_entry = create_fn_raw(g, FnInlineAuto);
 
-        get_fully_qualified_decl_name(&fn_table_entry->symbol_name, &tld_fn->base);
+        get_fully_qualified_decl_name(&fn_table_entry->symbol_name, &tld_fn->base, true);
 
         tld_fn->fn_entry = fn_table_entry;
 
@@ -3722,7 +3745,7 @@ static void analyze_fn_body(CodeGen *g, ZigFn *fn_table_entry) {
     }
     if (g->verbose_ir) {
         fprintf(stderr, "\n");
-        ast_render(g, stderr, fn_table_entry->body_node, 4);
+        ast_render(stderr, fn_table_entry->body_node, 4);
         fprintf(stderr, "\n{ // (IR)\n");
         ir_print(g, stderr, &fn_table_entry->ir_executable, 4);
         fprintf(stderr, "}\n");
@@ -5155,11 +5178,10 @@ bool const_values_equal(CodeGen *g, ConstExprValue *a, ConstExprValue *b) {
             if (bigint_cmp(&union1->tag, &union2->tag) == CmpEQ) {
                 TypeUnionField *field = find_union_field_by_tag(a->type, &union1->tag);
                 assert(field != nullptr);
-                if (type_has_bits(field->type_entry)) {
-                    zig_panic("TODO const expr analyze union field value for equality");
-                } else {
+                if (!type_has_bits(field->type_entry))
                     return true;
-                }
+                assert(find_union_field_by_tag(a->type, &union2->tag) != nullptr);
+                return const_values_equal(g, union1->payload, union2->payload);
             }
             return false;
         }
@@ -6070,7 +6092,7 @@ Error file_fetch(CodeGen *g, Buf *resolved_path, Buf *contents) {
     if (g->enable_cache) {
         return cache_add_file_fetch(&g->cache_hash, resolved_path, contents);
     } else {
-        return os_fetch_file_path(resolved_path, contents, false);
+        return os_fetch_file_path(resolved_path, contents);
     }
 }
 
@@ -7222,3 +7244,16 @@ ZigLLVMDIType *get_llvm_di_type(CodeGen *g, ZigType *type) {
     assertNoError(type_resolve(g, type, ResolveStatusLLVMFull));
     return type->llvm_di_type;
 }
+
+void src_assert(bool ok, AstNode *source_node) {
+    if (ok) return;
+    if (source_node == nullptr) {
+        fprintf(stderr, "when analyzing (unknown source location): ");
+    } else {
+        fprintf(stderr, "when analyzing %s:%u:%u: ",
+            buf_ptr(source_node->owner->data.structure.root_struct->path),
+            (unsigned)source_node->line + 1, (unsigned)source_node->column + 1);
+    }
+    const char *msg = "assertion failed";
+    stage2_panic(msg, strlen(msg));
+}
diff --git a/src/analyze.hpp b/src/analyze.hpp
index a3246fdf4d..d55733482f 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -247,4 +247,8 @@ Error create_c_object_cache(CodeGen *g, CacheHash **out_cache_hash, bool verbose
 LLVMTypeRef get_llvm_type(CodeGen *g, ZigType *type);
 ZigLLVMDIType *get_llvm_di_type(CodeGen *g, ZigType *type);
 
+void add_cc_args(CodeGen *g, ZigList<const char *> &args, const char *out_dep_path, bool translate_c);
+
+void src_assert(bool ok, AstNode *source_node);
+
 #endif
diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index 16f2aafa78..95ae216f70 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -296,7 +296,6 @@ void ast_print(FILE *f, AstNode *node, int indent) {
 
 
 struct AstRender {
-    CodeGen *codegen;
     int indent;
     int indent_size;
     FILE *f;
@@ -633,7 +632,7 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
                 if (is_printable(c)) {
                     fprintf(ar->f, "'%c'", c);
                 } else {
-                    fprintf(ar->f, "'\\x%x'", (int)c);
+                    fprintf(ar->f, "'\\x%02x'", (int)c);
                 }
                 break;
             }
@@ -1170,9 +1169,8 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
 }
 
 
-void ast_render(CodeGen *codegen, FILE *f, AstNode *node, int indent_size) {
+void ast_render(FILE *f, AstNode *node, int indent_size) {
     AstRender ar = {0};
-    ar.codegen = codegen;
     ar.f = f;
     ar.indent_size = indent_size;
     ar.indent = 0;
diff --git a/src/ast_render.hpp b/src/ast_render.hpp
index 1652156eee..cf70b04694 100644
--- a/src/ast_render.hpp
+++ b/src/ast_render.hpp
@@ -15,6 +15,6 @@
 
 void ast_print(FILE *f, AstNode *node, int indent);
 
-void ast_render(CodeGen *codegen, FILE *f, AstNode *node, int indent_size);
+void ast_render(FILE *f, AstNode *node, int indent_size);
 
 #endif
diff --git a/src/bigint.cpp b/src/bigint.cpp
index d3178c35c6..da53a2b129 100644
--- a/src/bigint.cpp
+++ b/src/bigint.cpp
@@ -1395,7 +1395,7 @@ void bigint_shr(BigInt *dest, const BigInt *op1, const BigInt *op2) {
     uint64_t shift_amt = bigint_as_unsigned(op2);
 
     if (op1->digit_count == 1) {
-        dest->data.digit = op1_digits[0] >> shift_amt;
+        dest->data.digit = (shift_amt < 64) ? op1_digits[0] >> shift_amt : 0;
         dest->digit_count = 1;
         dest->is_negative = op1->is_negative;
         bigint_normalize(dest);
@@ -1410,12 +1410,19 @@ void bigint_shr(BigInt *dest, const BigInt *op1, const BigInt *op2) {
     }
 
     dest->digit_count = op1->digit_count - digit_shift_count;
-    dest->data.digits = allocate<uint64_t>(dest->digit_count);
+    uint64_t *digits;
+    if (dest->digit_count == 1) {
+        digits = &dest->data.digit;
+    } else {
+        digits = allocate<uint64_t>(dest->digit_count);
+        dest->data.digits = digits;
+    }
+
     uint64_t carry = 0;
     for (size_t op_digit_index = op1->digit_count - 1;;) {
         uint64_t digit = op1_digits[op_digit_index];
         size_t dest_digit_index = op_digit_index - digit_shift_count;
-        dest->data.digits[dest_digit_index] = carry | (digit >> leftover_shift_count);
+        digits[dest_digit_index] = carry | (digit >> leftover_shift_count);
         carry = digit << (64 - leftover_shift_count);
 
         if (dest_digit_index == 0) { break; }
diff --git a/src/buffer.hpp b/src/buffer.hpp
index 789abea3e9..082d584e2c 100644
--- a/src/buffer.hpp
+++ b/src/buffer.hpp
@@ -10,7 +10,6 @@
 
 #include "list.hpp"
 
-#include <assert.h>
 #include <stdint.h>
 #include <ctype.h>
 #include <stdarg.h>
diff --git a/src/c_tokenizer.cpp b/src/c_tokenizer.cpp
index 40ae8ceafe..55fde19003 100644
--- a/src/c_tokenizer.cpp
+++ b/src/c_tokenizer.cpp
@@ -124,6 +124,8 @@ static void begin_token(CTokenize *ctok, CTokId id) {
         case CTokIdAsterisk:
         case CTokIdBang:
         case CTokIdTilde:
+        case CTokIdShl:
+        case CTokIdLt:
             break;
     }
 }
@@ -223,6 +225,10 @@ void tokenize_c_macro(CTokenize *ctok, const uint8_t *c) {
                         begin_token(ctok, CTokIdDot);
                         end_token(ctok);
                         break;
+                    case '<':
+                        begin_token(ctok, CTokIdLt);
+                        ctok->state = CTokStateGotLt;
+                        break;
                     case '(':
                         begin_token(ctok, CTokIdLParen);
                         end_token(ctok);
@@ -251,6 +257,19 @@ void tokenize_c_macro(CTokenize *ctok, const uint8_t *c) {
                         return mark_error(ctok);
                 }
                 break;
+            case CTokStateGotLt:
+                switch (*c) {
+                    case '<':
+                        ctok->cur_tok->id = CTokIdShl;
+                        end_token(ctok);
+                        ctok->state = CTokStateStart;
+                        break;
+                    default:
+                        end_token(ctok);
+                        ctok->state = CTokStateStart;
+                        continue;
+                }
+                break;
             case CTokStateFloat:
                 switch (*c) {
                     case '.':
@@ -791,6 +810,7 @@ found_end_of_macro:
         case CTokStateNumLitIntSuffixL:
         case CTokStateNumLitIntSuffixUL:
         case CTokStateNumLitIntSuffixLL:
+        case CTokStateGotLt:
             end_token(ctok);
             break;
         case CTokStateFloat:
diff --git a/src/c_tokenizer.hpp b/src/c_tokenizer.hpp
index d7c9e53bcf..eaca09098f 100644
--- a/src/c_tokenizer.hpp
+++ b/src/c_tokenizer.hpp
@@ -25,6 +25,8 @@ enum CTokId {
     CTokIdAsterisk,
     CTokIdBang,
     CTokIdTilde,
+    CTokIdShl,
+    CTokIdLt,
 };
 
 enum CNumLitSuffix {
@@ -78,6 +80,7 @@ enum CTokState {
     CTokStateNumLitIntSuffixL,
     CTokStateNumLitIntSuffixLL,
     CTokStateNumLitIntSuffixUL,
+    CTokStateGotLt,
 };
 
 struct CTokenize {
diff --git a/src/cache_hash.cpp b/src/cache_hash.cpp
index 1f25a9982e..2a0810eced 100644
--- a/src/cache_hash.cpp
+++ b/src/cache_hash.cpp
@@ -256,10 +256,10 @@ static Error populate_file_hash(CacheHash *ch, CacheHashFile *chf, Buf *contents
     }
 
     if ((err = hash_file(chf->bin_digest, this_file, contents))) {
-        os_file_close(this_file);
+        os_file_close(&this_file);
         return err;
     }
-    os_file_close(this_file);
+    os_file_close(&this_file);
 
     blake2b_update(&ch->blake, chf->bin_digest, 48);
 
@@ -300,7 +300,7 @@ Error cache_hit(CacheHash *ch, Buf *out_digest) {
     Buf line_buf = BUF_INIT;
     buf_resize(&line_buf, 512);
     if ((err = os_file_read_all(ch->manifest_file, &line_buf))) {
-        os_file_close(ch->manifest_file);
+        os_file_close(&ch->manifest_file);
         return err;
     }
 
@@ -389,14 +389,14 @@ Error cache_hit(CacheHash *ch, Buf *out_digest) {
         OsFileAttr actual_attr;
         if ((err = os_file_open_r(chf->path, &this_file, &actual_attr))) {
             fprintf(stderr, "Unable to open %s\n: %s", buf_ptr(chf->path), err_str(err));
-            os_file_close(ch->manifest_file);
+            os_file_close(&ch->manifest_file);
             return ErrorCacheUnavailable;
         }
         if (chf->attr.mtime.sec == actual_attr.mtime.sec &&
             chf->attr.mtime.nsec == actual_attr.mtime.nsec &&
             chf->attr.inode == actual_attr.inode)
         {
-            os_file_close(this_file);
+            os_file_close(&this_file);
         } else {
             // we have to recompute the digest.
             // later we'll rewrite the manifest with the new mtime/digest values
@@ -411,11 +411,11 @@ Error cache_hit(CacheHash *ch, Buf *out_digest) {
 
             uint8_t actual_digest[48];
             if ((err = hash_file(actual_digest, this_file, nullptr))) {
-                os_file_close(this_file);
-                os_file_close(ch->manifest_file);
+                os_file_close(&this_file);
+                os_file_close(&ch->manifest_file);
                 return err;
             }
-            os_file_close(this_file);
+            os_file_close(&this_file);
             if (memcmp(chf->bin_digest, actual_digest, 48) != 0) {
                 memcpy(chf->bin_digest, actual_digest, 48);
                 // keep going until we have the input file digests
@@ -433,12 +433,12 @@ Error cache_hit(CacheHash *ch, Buf *out_digest) {
             CacheHashFile *chf = &ch->files.at(file_i);
             if ((err = populate_file_hash(ch, chf, nullptr))) {
                 fprintf(stderr, "Unable to hash %s: %s\n", buf_ptr(chf->path), err_str(err));
-                os_file_close(ch->manifest_file);
+                os_file_close(&ch->manifest_file);
                 return ErrorCacheUnavailable;
             }
         }
-        if (return_code != ErrorNone) {
-            os_file_close(ch->manifest_file);
+        if (return_code != ErrorNone && return_code != ErrorInvalidFormat) {
+            os_file_close(&ch->manifest_file);
         }
         return return_code;
     }
@@ -453,7 +453,7 @@ Error cache_add_file_fetch(CacheHash *ch, Buf *resolved_path, Buf *contents) {
     CacheHashFile *chf = ch->files.add_one();
     chf->path = resolved_path;
     if ((err = populate_file_hash(ch, chf, contents))) {
-        os_file_close(ch->manifest_file);
+        os_file_close(&ch->manifest_file);
         return err;
     }
 
@@ -469,7 +469,7 @@ Error cache_add_file(CacheHash *ch, Buf *path) {
 Error cache_add_dep_file(CacheHash *ch, Buf *dep_file_path, bool verbose) {
     Error err;
     Buf *contents = buf_alloc();
-    if ((err = os_fetch_file_path(dep_file_path, contents, false))) {
+    if ((err = os_fetch_file_path(dep_file_path, contents))) {
         if (verbose) {
             fprintf(stderr, "unable to read .d file: %s\n", err_str(err));
         }
@@ -586,6 +586,6 @@ void cache_release(CacheHash *ch) {
         }
     }
 
-    os_file_close(ch->manifest_file);
+    os_file_close(&ch->manifest_file);
 }
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 568344fc09..d21ada1b23 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -19,6 +19,7 @@
 #include "target.hpp"
 #include "util.hpp"
 #include "zig_llvm.h"
+#include "userland.h"
 
 #include <stdio.h>
 #include <errno.h>
@@ -92,7 +93,7 @@ static const char *symbols_that_llvm_depends_on[] = {
 };
 
 CodeGen *codegen_create(Buf *main_pkg_path, Buf *root_src_path, const ZigTarget *target,
-    OutType out_type, BuildMode build_mode, Buf *zig_lib_dir, Buf *override_std_dir,
+    OutType out_type, BuildMode build_mode, Buf *override_lib_dir, Buf *override_std_dir,
     ZigLibCInstallation *libc, Buf *cache_dir)
 {
     CodeGen *g = allocate<CodeGen>(1);
@@ -100,19 +101,24 @@ CodeGen *codegen_create(Buf *main_pkg_path, Buf *root_src_path, const ZigTarget
     codegen_add_time_event(g, "Initialize");
 
     g->libc = libc;
-    g->zig_lib_dir = zig_lib_dir;
     g->zig_target = target;
     g->cache_dir = cache_dir;
 
+    if (override_lib_dir == nullptr) {
+        g->zig_lib_dir = get_zig_lib_dir();
+    } else {
+        g->zig_lib_dir = override_lib_dir;
+    }
+
     if (override_std_dir == nullptr) {
         g->zig_std_dir = buf_alloc();
-        os_path_join(zig_lib_dir, buf_create_from_str("std"), g->zig_std_dir);
+        os_path_join(g->zig_lib_dir, buf_create_from_str("std"), g->zig_std_dir);
     } else {
         g->zig_std_dir = override_std_dir;
     }
 
     g->zig_c_headers_dir = buf_alloc();
-    os_path_join(zig_lib_dir, buf_create_from_str("include"), g->zig_c_headers_dir);
+    os_path_join(g->zig_lib_dir, buf_create_from_str("include"), g->zig_c_headers_dir);
 
     g->build_mode = build_mode;
     g->out_type = out_type;
@@ -393,6 +399,15 @@ static void add_uwtable_attr(CodeGen *g, LLVMValueRef fn_val) {
     }
 }
 
+static void add_probe_stack_attr(CodeGen *g, LLVMValueRef fn_val) {
+    // Windows already emits its own stack probes
+    if (!g->disable_stack_probing && g->zig_target->os != OsWindows &&
+        (g->zig_target->arch == ZigLLVM_x86 ||
+         g->zig_target->arch == ZigLLVM_x86_64)) {
+        addLLVMFnAttrStr(fn_val, "probe-stack", "__zig_probe_stack");
+    }
+}
+
 static LLVMLinkage to_llvm_linkage(GlobalLinkageId id) {
     switch (id) {
         case GlobalLinkageIdInternal:
@@ -424,7 +439,7 @@ static uint32_t get_err_ret_trace_arg_index(CodeGen *g, ZigFn *fn_table_entry) {
 }
 
 static void maybe_export_dll(CodeGen *g, LLVMValueRef global_value, GlobalLinkageId linkage) {
-    if (linkage != GlobalLinkageIdInternal && g->zig_target->os == OsWindows) {
+    if (linkage != GlobalLinkageIdInternal && g->zig_target->os == OsWindows && g->is_dynamic) {
         LLVMSetDLLStorageClass(global_value, LLVMDLLExportStorageClass);
     }
 }
@@ -495,6 +510,14 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, ZigFn *fn_table_entry) {
             auto entry = g->exported_symbol_names.maybe_get(symbol_name);
             if (entry == nullptr) {
                 fn_table_entry->llvm_value = LLVMAddFunction(g->module, buf_ptr(symbol_name), fn_llvm_type);
+
+                if (target_is_wasm(g->zig_target)) {
+                    assert(fn_table_entry->proto_node->type == NodeTypeFnProto);
+                    AstNodeFnProto *fn_proto = &fn_table_entry->proto_node->data.fn_proto;
+                    if (fn_proto-> is_extern && fn_proto->lib_name != nullptr ) {
+                        addLLVMFnAttrStr(fn_table_entry->llvm_value, "wasm-import-module", buf_ptr(fn_proto->lib_name));
+                    }
+                }
             } else {
                 assert(entry->value->id == TldIdFn);
                 TldFn *tld_fn = reinterpret_cast<TldFn *>(entry->value);
@@ -573,6 +596,8 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, ZigFn *fn_table_entry) {
                 addLLVMFnAttr(fn_table_entry->llvm_value, "sspstrong");
                 addLLVMFnAttrStr(fn_table_entry->llvm_value, "stack-protector-buffer-size", "4");
             }
+
+            add_probe_stack_attr(g, fn_table_entry->llvm_value);
         }
     } else {
         maybe_import_dll(g, fn_table_entry->llvm_value, linkage);
@@ -983,10 +1008,19 @@ static void gen_panic(CodeGen *g, LLVMValueRef msg_arg, LLVMValueRef stack_trace
     LLVMBuildUnreachable(g->builder);
 }
 
+// TODO update most callsites to call gen_assertion instead of this
 static void gen_safety_crash(CodeGen *g, PanicMsgId msg_id) {
     gen_panic(g, get_panic_msg_ptr_val(g, msg_id), nullptr);
 }
 
+static void gen_assertion(CodeGen *g, PanicMsgId msg_id, IrInstruction *source_instruction) {
+    if (ir_want_runtime_safety(g, source_instruction)) {
+        gen_safety_crash(g, msg_id);
+    } else {
+        LLVMBuildUnreachable(g->builder);
+    }
+}
+
 static LLVMValueRef get_stacksave_fn_val(CodeGen *g) {
     if (g->stacksave_fn_val)
         return g->stacksave_fn_val;
@@ -1022,7 +1056,7 @@ static LLVMValueRef get_write_register_fn_val(CodeGen *g) {
     // !0 = !{!"sp\00"}
 
     LLVMTypeRef param_types[] = {
-        LLVMMetadataTypeInContext(LLVMGetGlobalContext()), 
+        LLVMMetadataTypeInContext(LLVMGetGlobalContext()),
         LLVMIntType(g->pointer_size_bytes * 8),
     };
 
@@ -1541,11 +1575,19 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
     LLVMValueRef offset_buf_ptr = LLVMConstInBoundsGEP(global_array, offset_ptr_indices, 2);
 
     Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_fail_unwrap"), false);
-    LLVMTypeRef arg_types[] = {
-        get_llvm_type(g, g->ptr_to_stack_trace_type),
-        get_llvm_type(g, g->err_tag_type),
-    };
-    LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 2, false);
+    LLVMTypeRef fn_type_ref;
+    if (g->have_err_ret_tracing) {
+        LLVMTypeRef arg_types[] = {
+            get_llvm_type(g, g->ptr_to_stack_trace_type),
+            get_llvm_type(g, g->err_tag_type),
+        };
+        fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 2, false);
+    } else {
+        LLVMTypeRef arg_types[] = {
+            get_llvm_type(g, g->err_tag_type),
+        };
+        fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 1, false);
+    }
     LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
     addLLVMFnAttr(fn_val, "noreturn");
     addLLVMFnAttr(fn_val, "cold");
@@ -1567,7 +1609,15 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
     LLVMPositionBuilderAtEnd(g->builder, entry_block);
     ZigLLVMClearCurrentDebugLocation(g->builder);
 
-    LLVMValueRef err_val = LLVMGetParam(fn_val, 1);
+    LLVMValueRef err_ret_trace_arg;
+    LLVMValueRef err_val;
+    if (g->have_err_ret_tracing) {
+        err_ret_trace_arg = LLVMGetParam(fn_val, 0);
+        err_val = LLVMGetParam(fn_val, 1);
+    } else {
+        err_ret_trace_arg = nullptr;
+        err_val = LLVMGetParam(fn_val, 0);
+    }
 
     LLVMValueRef err_table_indices[] = {
         LLVMConstNull(g->builtin_types.entry_usize->llvm_type),
@@ -1589,7 +1639,7 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
     LLVMValueRef global_slice_len_field_ptr = LLVMBuildStructGEP(g->builder, global_slice, slice_len_index, "");
     gen_store(g, full_buf_len, global_slice_len_field_ptr, u8_ptr_type);
 
-    gen_panic(g, global_slice, LLVMGetParam(fn_val, 0));
+    gen_panic(g, global_slice, err_ret_trace_arg);
 
     LLVMPositionBuilderAtEnd(g->builder, prev_block);
     LLVMSetCurrentDebugLocation(g->builder, prev_debug_location);
@@ -1625,17 +1675,26 @@ static LLVMValueRef get_cur_err_ret_trace_val(CodeGen *g, Scope *scope) {
 
 static void gen_safety_crash_for_err(CodeGen *g, LLVMValueRef err_val, Scope *scope) {
     LLVMValueRef safety_crash_err_fn = get_safety_crash_err_fn(g);
-    LLVMValueRef err_ret_trace_val = get_cur_err_ret_trace_val(g, scope);
-    if (err_ret_trace_val == nullptr) {
-        ZigType *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(g);
-        err_ret_trace_val = LLVMConstNull(get_llvm_type(g, ptr_to_stack_trace_type));
+    LLVMValueRef call_instruction;
+    if (g->have_err_ret_tracing) {
+        LLVMValueRef err_ret_trace_val = get_cur_err_ret_trace_val(g, scope);
+        if (err_ret_trace_val == nullptr) {
+            ZigType *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(g);
+            err_ret_trace_val = LLVMConstNull(get_llvm_type(g, ptr_to_stack_trace_type));
+        }
+        LLVMValueRef args[] = {
+            err_ret_trace_val,
+            err_val,
+        };
+        call_instruction = ZigLLVMBuildCall(g->builder, safety_crash_err_fn, args, 2,
+                get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_FnInlineAuto, "");
+    } else {
+        LLVMValueRef args[] = {
+            err_val,
+        };
+        call_instruction = ZigLLVMBuildCall(g->builder, safety_crash_err_fn, args, 1,
+                get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_FnInlineAuto, "");
     }
-    LLVMValueRef args[] = {
-        err_ret_trace_val,
-        err_val,
-    };
-    LLVMValueRef call_instruction = ZigLLVMBuildCall(g->builder, safety_crash_err_fn, args, 2, get_llvm_cc(g, CallingConventionUnspecified),
-        ZigLLVM_FnInlineAuto, "");
     LLVMSetTailCall(call_instruction, true);
     LLVMBuildUnreachable(g->builder);
 }
@@ -3452,6 +3511,15 @@ static bool want_valgrind_support(CodeGen *g) {
     zig_unreachable();
 }
 
+static void gen_valgrind_undef(CodeGen *g, LLVMValueRef dest_ptr, LLVMValueRef byte_count) {
+    static const uint32_t VG_USERREQ__MAKE_MEM_UNDEFINED = 1296236545;
+    ZigType *usize = g->builtin_types.entry_usize;
+    LLVMValueRef zero = LLVMConstInt(usize->llvm_type, 0, false);
+    LLVMValueRef req = LLVMConstInt(usize->llvm_type, VG_USERREQ__MAKE_MEM_UNDEFINED, false);
+    LLVMValueRef ptr_as_usize = LLVMBuildPtrToInt(g->builder, dest_ptr, usize->llvm_type, "");
+    gen_valgrind_client_request(g, zero, req, ptr_as_usize, byte_count, zero, zero, zero);
+}
+
 static void gen_undef_init(CodeGen *g, uint32_t ptr_align_bytes, ZigType *value_type, LLVMValueRef ptr) {
     assert(type_has_bits(value_type));
     uint64_t size_bytes = LLVMStoreSizeOfType(g->target_data_ref, get_llvm_type(g, value_type));
@@ -3466,11 +3534,7 @@ static void gen_undef_init(CodeGen *g, uint32_t ptr_align_bytes, ZigType *value_
     ZigLLVMBuildMemSet(g->builder, dest_ptr, fill_char, byte_count, ptr_align_bytes, false);
     // then tell valgrind that the memory is undefined even though we just memset it
     if (want_valgrind_support(g)) {
-        static const uint32_t VG_USERREQ__MAKE_MEM_UNDEFINED = 1296236545;
-        LLVMValueRef zero = LLVMConstInt(usize->llvm_type, 0, false);
-        LLVMValueRef req = LLVMConstInt(usize->llvm_type, VG_USERREQ__MAKE_MEM_UNDEFINED, false);
-        LLVMValueRef ptr_as_usize = LLVMBuildPtrToInt(g->builder, dest_ptr, usize->llvm_type, "");
-        gen_valgrind_client_request(g, zero, req, ptr_as_usize, byte_count, zero, zero, zero);
+        gen_valgrind_undef(g, dest_ptr, byte_count);
     }
 }
 
@@ -3480,14 +3544,14 @@ static LLVMValueRef ir_render_store_ptr(CodeGen *g, IrExecutable *executable, Ir
     if (!type_has_bits(ptr_type))
         return nullptr;
 
-    bool have_init_expr = !value_is_all_undef(&instruction->value->value); 
+    bool have_init_expr = !value_is_all_undef(&instruction->value->value);
     if (have_init_expr) {
         LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
         LLVMValueRef value = ir_llvm_value(g, instruction->value);
         gen_assign_raw(g, ptr, ptr_type, value);
     } else if (ir_want_runtime_safety(g, &instruction->base)) {
         gen_undef_init(g, get_ptr_align(g, ptr_type), instruction->value->value.type,
-            ir_llvm_value(g, instruction->ptr)); 
+            ir_llvm_value(g, instruction->ptr));
     }
     return nullptr;
 }
@@ -3690,7 +3754,7 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
     }
     FnWalk fn_walk = {};
     fn_walk.id = FnWalkIdCall;
-    fn_walk.data.call.inst = instruction; 
+    fn_walk.data.call.inst = instruction;
     fn_walk.data.call.is_var_args = is_var_args;
     fn_walk.data.call.gen_param_values = &gen_param_values;
     walk_function_params(g, fn_type, &fn_walk);
@@ -3710,7 +3774,7 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
 
     LLVMCallConv llvm_cc = get_llvm_cc(g, cc);
     LLVMValueRef result;
-    
+
     if (instruction->new_stack == nullptr) {
         result = ZigLLVMBuildCall(g->builder, fn_val,
                 gen_param_values.items, (unsigned)gen_param_values.length, llvm_cc, fn_inline, "");
@@ -3968,19 +4032,19 @@ static LLVMValueRef ir_render_asm(CodeGen *g, IrExecutable *executable, IrInstru
 }
 
 static LLVMValueRef gen_non_null_bit(CodeGen *g, ZigType *maybe_type, LLVMValueRef maybe_handle) {
-    assert(maybe_type->id == ZigTypeIdOptional);
+    assert(maybe_type->id == ZigTypeIdOptional ||
+            (maybe_type->id == ZigTypeIdPointer && maybe_type->data.pointer.allow_zero));
+
     ZigType *child_type = maybe_type->data.maybe.child_type;
-    if (!type_has_bits(child_type)) {
+    if (!type_has_bits(child_type))
         return maybe_handle;
-    } else {
-        bool is_scalar = !handle_is_ptr(maybe_type);
-        if (is_scalar) {
-            return LLVMBuildICmp(g->builder, LLVMIntNE, maybe_handle, LLVMConstNull(get_llvm_type(g, maybe_type)), "");
-        } else {
-            LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP(g->builder, maybe_handle, maybe_null_index, "");
-            return gen_load_untyped(g, maybe_field_ptr, 0, false, "");
-        }
-    }
+
+    bool is_scalar = !handle_is_ptr(maybe_type);
+    if (is_scalar)
+        return LLVMBuildICmp(g->builder, LLVMIntNE, maybe_handle, LLVMConstNull(get_llvm_type(g, maybe_type)), "");
+
+    LLVMValueRef maybe_field_ptr = LLVMBuildStructGEP(g->builder, maybe_handle, maybe_null_index, "");
+    return gen_load_untyped(g, maybe_field_ptr, 0, false, "");
 }
 
 static LLVMValueRef ir_render_test_non_null(CodeGen *g, IrExecutable *executable,
@@ -4001,8 +4065,8 @@ static LLVMValueRef ir_render_optional_unwrap_ptr(CodeGen *g, IrExecutable *exec
     if (ir_want_runtime_safety(g, &instruction->base) && instruction->safety_check_on) {
         LLVMValueRef maybe_handle = get_handle_value(g, maybe_ptr, maybe_type, ptr_type);
         LLVMValueRef non_null_bit = gen_non_null_bit(g, maybe_type, maybe_handle);
-        LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapOptionalOk");
         LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapOptionalFail");
+        LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "UnwrapOptionalOk");
         LLVMBuildCondBr(g->builder, non_null_bit, ok_block, fail_block);
 
         LLVMPositionBuilderAtEnd(g->builder, fail_block);
@@ -4190,7 +4254,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen *g, ZigType *enum_type) {
     LLVMTypeRef tag_int_llvm_type = get_llvm_type(g, tag_int_type);
     LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMPointerType(get_llvm_type(g, u8_slice_type), 0),
             &tag_int_llvm_type, 1, false);
-    
+
     Buf *fn_name = get_mangled_name(g, buf_sprintf("__zig_tag_name_%s", buf_ptr(&enum_type->name)), false);
     LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
     LLVMSetLinkage(fn_val, LLVMInternalLinkage);
@@ -4490,17 +4554,27 @@ static LLVMValueRef ir_render_truncate(CodeGen *g, IrExecutable *executable, IrI
 
 static LLVMValueRef ir_render_memset(CodeGen *g, IrExecutable *executable, IrInstructionMemset *instruction) {
     LLVMValueRef dest_ptr = ir_llvm_value(g, instruction->dest_ptr);
-    LLVMValueRef char_val = ir_llvm_value(g, instruction->byte);
     LLVMValueRef len_val = ir_llvm_value(g, instruction->count);
 
     LLVMTypeRef ptr_u8 = LLVMPointerType(LLVMInt8Type(), 0);
-
     LLVMValueRef dest_ptr_casted = LLVMBuildBitCast(g->builder, dest_ptr, ptr_u8, "");
 
     ZigType *ptr_type = instruction->dest_ptr->value.type;
     assert(ptr_type->id == ZigTypeIdPointer);
 
-    ZigLLVMBuildMemSet(g->builder, dest_ptr_casted, char_val, len_val, get_ptr_align(g, ptr_type), ptr_type->data.pointer.is_volatile);
+    bool val_is_undef = value_is_all_undef(&instruction->byte->value);
+    LLVMValueRef fill_char;
+    if (val_is_undef) {
+        fill_char = LLVMConstInt(LLVMInt8Type(), 0xaa, false);
+    } else {
+        fill_char = ir_llvm_value(g, instruction->byte);
+    }
+    ZigLLVMBuildMemSet(g->builder, dest_ptr_casted, fill_char, len_val, get_ptr_align(g, ptr_type),
+            ptr_type->data.pointer.is_volatile);
+
+    if (val_is_undef && want_valgrind_support(g)) {
+        gen_valgrind_undef(g, dest_ptr_casted, len_val);
+    }
     return nullptr;
 }
 
@@ -5422,6 +5496,31 @@ static LLVMValueRef ir_render_assert_zero(CodeGen *g, IrExecutable *executable,
     return nullptr;
 }
 
+static LLVMValueRef ir_render_assert_non_null(CodeGen *g, IrExecutable *executable,
+        IrInstructionAssertNonNull *instruction)
+{
+    LLVMValueRef target = ir_llvm_value(g, instruction->target);
+    ZigType *target_type = instruction->target->value.type;
+
+    if (target_type->id == ZigTypeIdPointer) {
+        assert(target_type->data.pointer.ptr_len == PtrLenC);
+        LLVMValueRef non_null_bit = LLVMBuildICmp(g->builder, LLVMIntNE, target,
+                LLVMConstNull(get_llvm_type(g, target_type)), "");
+
+        LLVMBasicBlockRef fail_block = LLVMAppendBasicBlock(g->cur_fn_val, "AssertNonNullFail");
+        LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "AssertNonNullOk");
+        LLVMBuildCondBr(g->builder, non_null_bit, ok_block, fail_block);
+
+        LLVMPositionBuilderAtEnd(g->builder, fail_block);
+        gen_assertion(g, PanicMsgIdUnwrapOptionalFail, &instruction->base);
+
+        LLVMPositionBuilderAtEnd(g->builder, ok_block);
+    } else {
+        zig_unreachable();
+    }
+    return nullptr;
+}
+
 static void set_debug_location(CodeGen *g, IrInstruction *instruction) {
     AstNode *source_node = instruction->source_node;
     Scope *scope = instruction->scope;
@@ -5676,6 +5775,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_vector_to_array(g, executable, (IrInstructionVectorToArray *)instruction);
         case IrInstructionIdAssertZero:
             return ir_render_assert_zero(g, executable, (IrInstructionAssertZero *)instruction);
+        case IrInstructionIdAssertNonNull:
+            return ir_render_assert_non_null(g, executable, (IrInstructionAssertNonNull *)instruction);
         case IrInstructionIdResizeSlice:
             return ir_render_resize_slice(g, executable, (IrInstructionResizeSlice *)instruction);
     }
@@ -6585,7 +6686,7 @@ static void validate_inline_fns(CodeGen *g) {
 }
 
 static void set_global_tls(CodeGen *g, ZigVar *var, LLVMValueRef global_value) {
-    if (var->is_thread_local && !g->is_single_threaded) {
+    if (var->is_thread_local && (!g->is_single_threaded || var->linkage != VarLinkageInternal)) {
         LLVMSetThreadLocalMode(global_value, LLVMGeneralDynamicTLSModel);
     }
 }
@@ -6905,7 +7006,7 @@ static void do_code_gen(CodeGen *g) {
         ir_render(g, fn_table_entry);
 
     }
-    
+
     assert(!g->errors.length);
 
     if (buf_len(&g->global_asm) != 0) {
@@ -6942,6 +7043,11 @@ static void zig_llvm_emit_output(CodeGen *g) {
             }
             validate_inline_fns(g);
             g->link_objects.append(output_path);
+            if (g->bundle_compiler_rt && (g->out_type == OutTypeObj ||
+                (g->out_type == OutTypeLib && !g->is_dynamic)))
+            {
+                zig_link_add_compiler_rt(g);
+            }
             break;
 
         case EmitFileTypeAssembly:
@@ -7337,9 +7443,26 @@ static bool detect_pic(CodeGen *g) {
     zig_unreachable();
 }
 
+static bool detect_single_threaded(CodeGen *g) {
+    if (g->want_single_threaded)
+        return true;
+    if (target_is_single_threaded(g->zig_target)) {
+        return true;
+    }
+    return false;
+}
+
+static bool detect_err_ret_tracing(CodeGen *g) {
+    return !target_is_wasm(g->zig_target) &&
+        g->build_mode != BuildModeFastRelease &&
+        g->build_mode != BuildModeSmallRelease;
+}
+
 Buf *codegen_generate_builtin_source(CodeGen *g) {
     g->have_dynamic_link = detect_dynamic_link(g);
     g->have_pic = detect_pic(g);
+    g->is_single_threaded = detect_single_threaded(g);
+    g->have_err_ret_tracing = detect_err_ret_tracing(g);
 
     Buf *contents = buf_alloc();
 
@@ -7696,7 +7819,7 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
         assert(ContainerLayoutAuto == 0);
         assert(ContainerLayoutExtern == 1);
         assert(ContainerLayoutPacked == 2);
-    
+
         assert(CallingConventionUnspecified == 0);
         assert(CallingConventionC == 1);
         assert(CallingConventionCold == 2);
@@ -7814,7 +7937,7 @@ static Error define_builtin_compile_vars(CodeGen *g) {
     Buf *contents;
     if (hit) {
         contents = buf_alloc();
-        if ((err = os_fetch_file_path(builtin_zig_path, contents, false))) {
+        if ((err = os_fetch_file_path(builtin_zig_path, contents))) {
             fprintf(stderr, "Unable to open '%s': %s\n", buf_ptr(builtin_zig_path), err_str(err));
             exit(1);
         }
@@ -7844,6 +7967,12 @@ static void init(CodeGen *g) {
 
     g->have_dynamic_link = detect_dynamic_link(g);
     g->have_pic = detect_pic(g);
+    g->is_single_threaded = detect_single_threaded(g);
+    g->have_err_ret_tracing = detect_err_ret_tracing(g);
+
+    if (target_is_single_threaded(g->zig_target)) {
+        g->is_single_threaded = true;
+    }
 
     if (g->is_test_build) {
         g->subsystem = TargetSubsystemConsole;
@@ -7953,8 +8082,6 @@ static void init(CodeGen *g) {
         }
     }
 
-    g->have_err_ret_tracing = g->build_mode != BuildModeFastRelease && g->build_mode != BuildModeSmallRelease;
-
     define_builtin_fns(g);
     Error err;
     if ((err = define_builtin_compile_vars(g))) {
@@ -8093,7 +8220,126 @@ static void detect_libc(CodeGen *g) {
     }
 }
 
-AstNode *codegen_translate_c(CodeGen *g, Buf *full_path) {
+// does not add the "cc" arg
+void add_cc_args(CodeGen *g, ZigList<const char *> &args, const char *out_dep_path, bool translate_c) {
+    if (translate_c) {
+        args.append("-x");
+        args.append("c");
+    }
+
+    if (out_dep_path != nullptr) {
+        args.append("-MD");
+        args.append("-MV");
+        args.append("-MF");
+        args.append(out_dep_path);
+    }
+
+    args.append("-nostdinc");
+    args.append("-fno-spell-checking");
+
+    if (translate_c) {
+        // this gives us access to preprocessing entities, presumably at
+        // the cost of performance
+        args.append("-Xclang");
+        args.append("-detailed-preprocessing-record");
+    } else {
+        switch (g->err_color) {
+            case ErrColorAuto:
+                break;
+            case ErrColorOff:
+                args.append("-fno-color-diagnostics");
+                args.append("-fno-caret-diagnostics");
+                break;
+            case ErrColorOn:
+                args.append("-fcolor-diagnostics");
+                args.append("-fcaret-diagnostics");
+                break;
+        }
+    }
+
+    args.append("-isystem");
+    args.append(buf_ptr(g->zig_c_headers_dir));
+
+    for (size_t i = 0; i < g->libc_include_dir_len; i += 1) {
+        Buf *include_dir = g->libc_include_dir_list[i];
+        args.append("-isystem");
+        args.append(buf_ptr(include_dir));
+    }
+
+    if (g->zig_target->is_native) {
+        args.append("-march=native");
+    } else {
+        args.append("-target");
+        args.append(buf_ptr(&g->triple_str));
+    }
+    if (g->zig_target->os == OsFreestanding) {
+        args.append("-ffreestanding");
+    }
+
+    if (!g->strip_debug_symbols) {
+        args.append("-g");
+    }
+
+    switch (g->build_mode) {
+        case BuildModeDebug:
+            // windows c runtime requires -D_DEBUG if using debug libraries
+            args.append("-D_DEBUG");
+
+            if (g->libc_link_lib != nullptr) {
+                args.append("-fstack-protector-strong");
+                args.append("--param");
+                args.append("ssp-buffer-size=4");
+            } else {
+                args.append("-fno-stack-protector");
+            }
+            args.append("-fno-omit-frame-pointer");
+            break;
+        case BuildModeSafeRelease:
+            // See the comment in the BuildModeFastRelease case for why we pass -O2 rather
+            // than -O3 here.
+            args.append("-O2");
+            if (g->libc_link_lib != nullptr) {
+                args.append("-D_FORTIFY_SOURCE=2");
+                args.append("-fstack-protector-strong");
+                args.append("--param");
+                args.append("ssp-buffer-size=4");
+            } else {
+                args.append("-fno-stack-protector");
+            }
+            args.append("-fomit-frame-pointer");
+            break;
+        case BuildModeFastRelease:
+            args.append("-DNDEBUG");
+            // Here we pass -O2 rather than -O3 because, although we do the equivalent of
+            // -O3 in Zig code, the justification for the difference here is that Zig
+            // has better detection and prevention of undefined behavior, so -O3 is safer for
+            // Zig code than it is for C code. Also, C programmers are used to their code
+            // running in -O2 and thus the -O3 path has been tested less.
+            args.append("-O2");
+            args.append("-fno-stack-protector");
+            args.append("-fomit-frame-pointer");
+            break;
+        case BuildModeSmallRelease:
+            args.append("-DNDEBUG");
+            args.append("-Os");
+            args.append("-fno-stack-protector");
+            args.append("-fomit-frame-pointer");
+            break;
+    }
+
+    if (target_supports_fpic(g->zig_target) && g->have_pic) {
+        args.append("-fPIC");
+    }
+
+    for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) {
+        args.append(g->clang_argv[arg_i]);
+    }
+
+
+}
+
+void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_userland_implementation) {
+    Error err;
     Buf *src_basename = buf_alloc();
     Buf *src_dirname = buf_alloc();
     os_path_split(full_path, src_dirname, src_basename);
@@ -8105,13 +8351,47 @@ AstNode *codegen_translate_c(CodeGen *g, Buf *full_path) {
 
     init(g);
 
-    ZigList<ErrorMsg *> errors = {0};
+    Stage2TranslateMode trans_mode = buf_ends_with_str(full_path, ".h") ?
+        Stage2TranslateModeImport : Stage2TranslateModeTranslate;
+
+
+    ZigList<const char *> clang_argv = {0};
+    add_cc_args(g, clang_argv, nullptr, true);
+
+    clang_argv.append(buf_ptr(full_path));
+
+    if (g->verbose_cc) {
+        fprintf(stderr, "clang");
+        for (size_t i = 0; i < clang_argv.length; i += 1) {
+            fprintf(stderr, " %s", clang_argv.at(i));
+        }
+        fprintf(stderr, "\n");
+    }
+
+    clang_argv.append(nullptr); // to make the [start...end] argument work
+
+    const char *resources_path = buf_ptr(g->zig_c_headers_dir);
+    Stage2ErrorMsg *errors_ptr;
+    size_t errors_len;
+    Stage2Ast *ast;
     AstNode *root_node;
-    Error err = parse_h_file(&root_node, &errors, buf_ptr(full_path), g, nullptr);
 
-    if (err == ErrorCCompileErrors && errors.length > 0) {
-        for (size_t i = 0; i < errors.length; i += 1) {
-            ErrorMsg *err_msg = errors.at(i);
+    if (use_userland_implementation) {
+        err = stage2_translate_c(&ast, &errors_ptr, &errors_len,
+                        &clang_argv.at(0), &clang_argv.last(), trans_mode, resources_path);
+    } else {
+        err = parse_h_file(g, &root_node, &errors_ptr, &errors_len, &clang_argv.at(0), &clang_argv.last(),
+                trans_mode, resources_path);
+    }
+
+    if (err == ErrorCCompileErrors && errors_len > 0) {
+        for (size_t i = 0; i < errors_len; i += 1) {
+            Stage2ErrorMsg *clang_err = &errors_ptr[i];
+            ErrorMsg *err_msg = err_msg_create_with_offset(
+                    clang_err->filename_ptr ?
+                        buf_create_from_mem(clang_err->filename_ptr, clang_err->filename_len) : buf_alloc(),
+                    clang_err->line, clang_err->column, clang_err->offset, clang_err->source,
+                    buf_create_from_mem(clang_err->msg_ptr, clang_err->msg_len));
             print_err_msg(err_msg, g->err_color);
         }
         exit(1);
@@ -8122,7 +8402,12 @@ AstNode *codegen_translate_c(CodeGen *g, Buf *full_path) {
         exit(1);
     }
 
-    return root_node;
+
+    if (use_userland_implementation) {
+        stage2_render_ast(ast, out_file);
+    } else {
+        ast_render(out_file, root_node, 4);
+    }
 }
 
 static ZigType *add_special_code(CodeGen *g, ZigPackage *package, const char *basename) {
@@ -8233,7 +8518,7 @@ static void gen_root_source(CodeGen *g) {
     Error err;
     // No need for using the caching system for this file fetch because it is handled
     // separately.
-    if ((err = os_fetch_file_path(resolved_path, source_code, true))) {
+    if ((err = os_fetch_file_path(resolved_path, source_code))) {
         fprintf(stderr, "unable to open '%s': %s\n", buf_ptr(resolved_path), err_str(err));
         exit(1);
     }
@@ -8308,7 +8593,7 @@ static void gen_global_asm(CodeGen *g) {
         Buf *asm_file = g->assembly_files.at(i);
         // No need to use the caching system for these fetches because they
         // are handled separately.
-        if ((err = os_fetch_file_path(asm_file, &contents,  false))) {
+        if ((err = os_fetch_file_path(asm_file, &contents))) {
             zig_panic("Unable to read %s: %s", buf_ptr(asm_file), err_str(err));
         }
         buf_append_buf(&g->global_asm, &contents);
@@ -8441,90 +8726,7 @@ static void gen_c_object(CodeGen *g, Buf *self_exe_path, CFile *c_file) {
         args.append("cc");
 
         Buf *out_dep_path = buf_sprintf("%s.d", buf_ptr(out_obj_path));
-        args.append("-MD");
-        args.append("-MV");
-        args.append("-MF");
-        args.append(buf_ptr(out_dep_path));
-
-        args.append("-nostdinc");
-        args.append("-fno-spell-checking");
-
-        switch (g->err_color) {
-            case ErrColorAuto:
-                break;
-            case ErrColorOff:
-                args.append("-fno-color-diagnostics");
-                args.append("-fno-caret-diagnostics");
-                break;
-            case ErrColorOn:
-                args.append("-fcolor-diagnostics");
-                args.append("-fcaret-diagnostics");
-                break;
-        }
-
-        args.append("-isystem");
-        args.append(buf_ptr(g->zig_c_headers_dir));
-
-        for (size_t i = 0; i < g->libc_include_dir_len; i += 1) {
-            Buf *include_dir = g->libc_include_dir_list[i];
-            args.append("-isystem");
-            args.append(buf_ptr(include_dir));
-        }
-
-        if (g->zig_target->is_native) {
-            args.append("-march=native");
-        } else {
-            args.append("-target");
-            args.append(buf_ptr(&g->triple_str));
-        }
-
-        if (!g->strip_debug_symbols) {
-            args.append("-g");
-        }
-
-        switch (g->build_mode) {
-            case BuildModeDebug:
-                if (g->libc_link_lib != nullptr) {
-                    args.append("-fstack-protector-strong");
-                    args.append("--param");
-                    args.append("ssp-buffer-size=4");
-                } else {
-                    args.append("-fno-stack-protector");
-                }
-                args.append("-fno-omit-frame-pointer");
-                break;
-            case BuildModeSafeRelease:
-                // See the comment in the BuildModeFastRelease case for why we pass -O2 rather
-                // than -O3 here.
-                args.append("-O2");
-                if (g->libc_link_lib != nullptr) {
-                    args.append("-D_FORTIFY_SOURCE=2");
-                    args.append("-fstack-protector-strong");
-                    args.append("--param");
-                    args.append("ssp-buffer-size=4");
-                } else {
-                    args.append("-fno-stack-protector");
-                }
-                args.append("-fomit-frame-pointer");
-                break;
-            case BuildModeFastRelease:
-                args.append("-DNDEBUG");
-                // Here we pass -O2 rather than -O3 because, although we do the equivalent of
-                // -O3 in Zig code, the justification for the difference here is that Zig
-                // has better detection and prevention of undefined behavior, so -O3 is safer for
-                // Zig code than it is for C code. Also, C programmers are used to their code
-                // running in -O2 and thus the -O3 path has been tested less.
-                args.append("-O2");
-                args.append("-fno-stack-protector");
-                args.append("-fomit-frame-pointer");
-                break;
-            case BuildModeSmallRelease:
-                args.append("-DNDEBUG");
-                args.append("-Os");
-                args.append("-fno-stack-protector");
-                args.append("-fomit-frame-pointer");
-                break;
-        }
+        add_cc_args(g, args, buf_ptr(out_dep_path), false);
 
         args.append("-o");
         args.append(buf_ptr(out_obj_path));
@@ -8532,19 +8734,10 @@ static void gen_c_object(CodeGen *g, Buf *self_exe_path, CFile *c_file) {
         args.append("-c");
         args.append(buf_ptr(c_source_file));
 
-        if (target_supports_fpic(g->zig_target) && g->have_pic) {
-            args.append("-fPIC");
-        }
-
-        for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) {
-            args.append(g->clang_argv[arg_i]);
-        }
-
         for (size_t arg_i = 0; arg_i < c_file->args.length; arg_i += 1) {
             args.append(c_file->args.at(arg_i));
         }
 
-
         if (g->verbose_cc) {
             print_zig_cc_cmd("zig", &args);
         }
@@ -9158,6 +9351,8 @@ static Error check_cache(CodeGen *g, Buf *manifest_dir, Buf *digest) {
     cache_bool(ch, g->linker_rdynamic);
     cache_bool(ch, g->each_lib_rpath);
     cache_bool(ch, g->disable_gen_h);
+    cache_bool(ch, g->bundle_compiler_rt);
+    cache_bool(ch, g->disable_stack_probing);
     cache_bool(ch, want_valgrind_support(g));
     cache_bool(ch, g->have_pic);
     cache_bool(ch, g->have_dynamic_link);
@@ -9268,6 +9463,8 @@ void codegen_build_and_link(CodeGen *g) {
 
     g->have_dynamic_link = detect_dynamic_link(g);
     g->have_pic = detect_pic(g);
+    g->is_single_threaded = detect_single_threaded(g);
+    g->have_err_ret_tracing = detect_err_ret_tracing(g);
     detect_libc(g);
     detect_dynamic_linker(g);
 
diff --git a/src/codegen.hpp b/src/codegen.hpp
index 3befca2de5..47c0097e4b 100644
--- a/src/codegen.hpp
+++ b/src/codegen.hpp
@@ -12,6 +12,7 @@
 #include "errmsg.hpp"
 #include "target.hpp"
 #include "libc_installation.hpp"
+#include "userland.h"
 
 #include <stdio.h>
 
@@ -43,6 +44,7 @@ void codegen_set_lib_version(CodeGen *g, size_t major, size_t minor, size_t patc
 void codegen_add_time_event(CodeGen *g, const char *name);
 void codegen_print_timing_report(CodeGen *g, FILE *f);
 void codegen_link(CodeGen *g);
+void zig_link_add_compiler_rt(CodeGen *g);
 void codegen_build_and_link(CodeGen *g);
 
 ZigPackage *codegen_create_package(CodeGen *g, const char *root_src_dir, const char *root_src_path,
@@ -50,7 +52,7 @@ ZigPackage *codegen_create_package(CodeGen *g, const char *root_src_dir, const c
 void codegen_add_assembly(CodeGen *g, Buf *path);
 void codegen_add_object(CodeGen *g, Buf *object_path);
 
-AstNode *codegen_translate_c(CodeGen *g, Buf *path);
+void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_userland_implementation);
 
 Buf *codegen_generate_builtin_source(CodeGen *g);
 
diff --git a/src/compiler.cpp b/src/compiler.cpp
index af62173db7..8bfe87bfcd 100644
--- a/src/compiler.cpp
+++ b/src/compiler.cpp
@@ -179,24 +179,24 @@ Buf *get_zig_lib_dir(void) {
     return &saved_lib_dir;
 }
 
-Buf *get_zig_std_dir() {
+Buf *get_zig_std_dir(Buf *zig_lib_dir) {
     if (saved_std_dir.list.length != 0) {
         return &saved_std_dir;
     }
     buf_resize(&saved_std_dir, 0);
 
-    os_path_join(get_zig_lib_dir(), buf_create_from_str("std"), &saved_std_dir);
+    os_path_join(zig_lib_dir, buf_create_from_str("std"), &saved_std_dir);
 
     return &saved_std_dir;
 }
 
-Buf *get_zig_special_dir() {
+Buf *get_zig_special_dir(Buf *zig_lib_dir) {
     if (saved_special_dir.list.length != 0) {
         return &saved_special_dir;
     }
     buf_resize(&saved_special_dir, 0);
 
-    os_path_join(get_zig_std_dir(), buf_sprintf("special"), &saved_special_dir);
+    os_path_join(get_zig_std_dir(zig_lib_dir), buf_sprintf("special"), &saved_special_dir);
 
     return &saved_special_dir;
 }
diff --git a/src/compiler.hpp b/src/compiler.hpp
index f2788b9998..4d682ba2fa 100644
--- a/src/compiler.hpp
+++ b/src/compiler.hpp
@@ -16,7 +16,7 @@ Error get_compiler_id(Buf **result);
 Buf *get_self_dynamic_linker_path(void);
 
 Buf *get_zig_lib_dir(void);
-Buf *get_zig_special_dir(void);
-Buf *get_zig_std_dir(void);
+Buf *get_zig_special_dir(Buf *zig_lib_dir);
+Buf *get_zig_std_dir(Buf *zig_lib_dir);
 
 #endif
diff --git a/src/error.cpp b/src/error.cpp
index 84b78aba1b..69676f9cf5 100644
--- a/src/error.cpp
+++ b/src/error.cpp
@@ -50,6 +50,10 @@ const char *err_str(Error err) {
         case ErrorUnexpectedWriteFailure: return "unexpected write failure";
         case ErrorUnexpectedSeekFailure: return "unexpected seek failure";
         case ErrorUnexpectedFileTruncationFailure: return "unexpected file truncation failure";
+        case ErrorUnimplemented: return "unimplemented";
+        case ErrorOperationAborted: return "operation aborted";
+        case ErrorBrokenPipe: return "broken pipe";
+        case ErrorNoSpaceLeft: return "no space left";
     }
     return "(invalid error)";
 }
diff --git a/src/error.hpp b/src/error.hpp
index d943703268..3ff36e1a5f 100644
--- a/src/error.hpp
+++ b/src/error.hpp
@@ -8,56 +8,10 @@
 #ifndef ERROR_HPP
 #define ERROR_HPP
 
-#include <assert.h>
-
-enum Error {
-    ErrorNone,
-    ErrorNoMem,
-    ErrorInvalidFormat,
-    ErrorSemanticAnalyzeFail,
-    ErrorAccess,
-    ErrorInterrupted,
-    ErrorSystemResources,
-    ErrorFileNotFound,
-    ErrorFileSystem,
-    ErrorFileTooBig,
-    ErrorDivByZero,
-    ErrorOverflow,
-    ErrorPathAlreadyExists,
-    ErrorUnexpected,
-    ErrorExactDivRemainder,
-    ErrorNegativeDenominator,
-    ErrorShiftedOutOneBits,
-    ErrorCCompileErrors,
-    ErrorEndOfFile,
-    ErrorIsDir,
-    ErrorNotDir,
-    ErrorUnsupportedOperatingSystem,
-    ErrorSharingViolation,
-    ErrorPipeBusy,
-    ErrorPrimitiveTypeNotFound,
-    ErrorCacheUnavailable,
-    ErrorPathTooLong,
-    ErrorCCompilerCannotFindFile,
-    ErrorReadingDepFile,
-    ErrorInvalidDepFile,
-    ErrorMissingArchitecture,
-    ErrorMissingOperatingSystem,
-    ErrorUnknownArchitecture,
-    ErrorUnknownOperatingSystem,
-    ErrorUnknownABI,
-    ErrorInvalidFilename,
-    ErrorDiskQuota,
-    ErrorDiskSpace,
-    ErrorUnexpectedWriteFailure,
-    ErrorUnexpectedSeekFailure,
-    ErrorUnexpectedFileTruncationFailure,
-};
+#include "userland.h"
 
 const char *err_str(Error err);
 
-static inline void assertNoError(Error err) {
-    assert(err == ErrorNone);
-}
+#define assertNoError(err) assert((err) == ErrorNone);
 
 #endif
diff --git a/src/ir.cpp b/src/ir.cpp
index c572e3c885..e89d30232e 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -188,6 +188,19 @@ static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *c
     assert(get_src_ptr_type(const_val->type) != nullptr);
     assert(const_val->special == ConstValSpecialStatic);
     ConstExprValue *result;
+    
+    switch (type_has_one_possible_value(g, const_val->type->data.pointer.child_type)) {
+        case OnePossibleValueInvalid:
+            zig_unreachable();
+        case OnePossibleValueYes:
+            result = create_const_vals(1);
+            result->type = const_val->type->data.pointer.child_type;
+            result->special = ConstValSpecialStatic;
+            return result;
+        case OnePossibleValueNo:
+            break;
+    }
+    
     switch (const_val->data.x_ptr.special) {
         case ConstPtrSpecialInvalid:
             zig_unreachable();
@@ -356,6 +369,18 @@ static void ir_ref_var(ZigVar *var) {
     var->ref_count += 1;
 }
 
+ZigType *ir_analyze_type_expr(IrAnalyze *ira, Scope *scope, AstNode *node) {
+    ConstExprValue *result = ir_eval_const_value(ira->codegen, scope, node, ira->codegen->builtin_types.entry_type,
+            ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, nullptr, nullptr,
+            node, nullptr, ira->new_irb.exec, nullptr);
+
+    if (type_is_invalid(result->type))
+        return ira->codegen->builtin_types.entry_invalid;
+
+    assert(result->special != ConstValSpecialRuntime);
+    return result->data.x_type;
+}
+
 static IrBasicBlock *ir_create_basic_block(IrBuilder *irb, Scope *scope, const char *name_hint) {
     IrBasicBlock *result = allocate<IrBasicBlock>(1);
     result->scope = scope;
@@ -978,6 +1003,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionAssertZero *) {
     return IrInstructionIdAssertZero;
 }
 
+static constexpr IrInstructionId ir_instruction_id(IrInstructionAssertNonNull *) {
+    return IrInstructionIdAssertNonNull;
+}
+
 template<typename T>
 static T *ir_create_instruction(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     T *special_instruction = allocate<T>(1);
@@ -3012,6 +3041,19 @@ static IrInstruction *ir_build_assert_zero(IrAnalyze *ira, IrInstruction *source
     return &instruction->base;
 }
 
+static IrInstruction *ir_build_assert_non_null(IrAnalyze *ira, IrInstruction *source_instruction,
+        IrInstruction *target)
+{
+    IrInstructionAssertNonNull *instruction = ir_build_instruction<IrInstructionAssertNonNull>(&ira->new_irb,
+        source_instruction->scope, source_instruction->source_node);
+    instruction->base.value.type = ira->codegen->builtin_types.entry_void;
+    instruction->target = target;
+
+    ir_ref_instruction(target, ira->new_irb.current_basic_block);
+
+    return &instruction->base;
+}
+
 static void ir_count_defers(IrBuilder *irb, Scope *inner_scope, Scope *outer_scope, size_t *results) {
     results[ReturnKindUnconditional] = 0;
     results[ReturnKindError] = 0;
@@ -5391,10 +5433,9 @@ static IrInstruction *ir_gen_var_decl(IrBuilder *irb, Scope *scope, AstNode *nod
         add_node_error(irb->codegen, variable_declaration->section_expr,
             buf_sprintf("cannot set section of local variable '%s'", buf_ptr(variable_declaration->symbol)));
     }
-    if (variable_declaration->threadlocal_tok != nullptr) {
-        add_token_error(irb->codegen, node->owner, variable_declaration->threadlocal_tok,
-            buf_sprintf("function-local variable '%s' cannot be threadlocal", buf_ptr(variable_declaration->symbol)));
-    }
+
+    // Parser should ensure that this never happens
+    assert(variable_declaration->threadlocal_tok == nullptr);
 
     // Temporarily set the name of the IrExecutable to the VariableDeclaration
     // so that the struct or enum from the init expression inherits the name.
@@ -5767,8 +5808,10 @@ static IrInstruction *ir_gen_for_expr(IrBuilder *irb, Scope *parent_scope, AstNo
 
     IrInstruction *body_result = ir_gen_node(irb, body_node, &loop_scope->base);
 
-    if (!instr_is_unreachable(body_result))
+    if (!instr_is_unreachable(body_result)) {
+        ir_mark_gen(ir_build_check_statement_is_void(irb, child_scope, node->data.for_expr.body, body_result));
         ir_mark_gen(ir_build_br(irb, child_scope, node, continue_block, is_comptime));
+    }
 
     ir_set_cursor_at_end_and_append_block(irb, continue_block);
     IrInstruction *new_index_val = ir_build_bin_op(irb, child_scope, node, IrBinOpAdd, index_val, one, false);
@@ -7891,6 +7934,11 @@ static ErrorMsg *ir_add_error(IrAnalyze *ira, IrInstruction *source_instruction,
     return ir_add_error_node(ira, source_instruction->source_node, msg);
 }
 
+static void ir_assert(bool ok, IrInstruction *source_instruction) {
+    if (ok) return;
+    src_assert(ok, source_instruction->source_node);
+}
+
 // This function takes a comptime ptr and makes the child const value conform to the type
 // described by the pointer.
 static Error eval_comptime_ptr_reinterpret(IrAnalyze *ira, CodeGen *codegen, AstNode *source_node,
@@ -7943,7 +7991,7 @@ static ConstExprValue *ir_exec_const_result(CodeGen *codegen, IrExecutable *exec
             return &codegen->invalid_instruction->value;
         }
     }
-    return &codegen->invalid_instruction->value;
+    zig_unreachable();
 }
 
 static bool ir_emit_global_runtime_side_effect(IrAnalyze *ira, IrInstruction *source_instruction) {
@@ -8088,6 +8136,8 @@ static void float_init_bigfloat(ConstExprValue *dest_val, BigFloat *bigfloat) {
             case 64:
                 dest_val->data.x_f64 = bigfloat_to_f64(bigfloat);
                 break;
+            case 80:
+                zig_panic("TODO");
             case 128:
                 dest_val->data.x_f128 = bigfloat_to_f128(bigfloat);
                 break;
@@ -9904,6 +9954,7 @@ static void ir_add_alloca(IrAnalyze *ira, IrInstruction *instruction, ZigType *t
 
 static void copy_const_val(ConstExprValue *dest, ConstExprValue *src, bool same_global_refs) {
     ConstGlobalRefs *global_refs = dest->global_refs;
+    assert(!same_global_refs || src->global_refs != nullptr);
     *dest = *src;
     if (!same_global_refs) {
         dest->global_refs = global_refs;
@@ -9949,6 +10000,8 @@ static bool eval_const_expr_implicit_cast(IrAnalyze *ira, IrInstruction *source_
                     case 64:
                         const_val->data.x_f64 = bigfloat_to_f64(&other_val->data.x_bigfloat);
                         break;
+                    case 80:
+                        zig_panic("TODO");
                     case 128:
                         const_val->data.x_f128 = bigfloat_to_f128(&other_val->data.x_bigfloat);
                         break;
@@ -9978,6 +10031,8 @@ static bool eval_const_expr_implicit_cast(IrAnalyze *ira, IrInstruction *source_
                     case 64:
                         const_val->data.x_f64 = bigfloat_to_f64(&bigfloat);
                         break;
+                    case 80:
+                        zig_panic("TODO");
                     case 128:
                         const_val->data.x_f128 = bigfloat_to_f128(&bigfloat);
                         break;
@@ -10170,6 +10225,7 @@ static void ir_finish_bb(IrAnalyze *ira) {
         ira->instruction_index += 1;
     }
 
+    size_t my_old_bb_index = ira->old_bb_index;
     ira->old_bb_index += 1;
 
     bool need_repeat = true;
@@ -10180,7 +10236,7 @@ static void ir_finish_bb(IrAnalyze *ira) {
                 ira->old_bb_index += 1;
                 continue;
             }
-            if (old_bb->other->instruction_list.length != 0) {
+            if (old_bb->other->instruction_list.length != 0 || ira->old_bb_index == my_old_bb_index) {
                 ira->old_bb_index += 1;
                 continue;
             }
@@ -10205,16 +10261,18 @@ static IrInstruction *ir_unreach_error(IrAnalyze *ira) {
 
 static bool ir_emit_backward_branch(IrAnalyze *ira, IrInstruction *source_instruction) {
     size_t *bbc = ira->new_irb.exec->backward_branch_count;
-    size_t quota = ira->new_irb.exec->backward_branch_quota;
+    size_t *quota = ira->new_irb.exec->backward_branch_quota;
 
     // If we're already over quota, we've already given an error message for this.
-    if (*bbc > quota) {
+    if (*bbc > *quota) {
+        assert(ira->codegen->errors.length > 0);
         return false;
     }
 
     *bbc += 1;
-    if (*bbc > quota) {
-        ir_add_error(ira, source_instruction, buf_sprintf("evaluation exceeded %" ZIG_PRI_usize " backwards branches", quota));
+    if (*bbc > *quota) {
+        ir_add_error(ira, source_instruction,
+                buf_sprintf("evaluation exceeded %" ZIG_PRI_usize " backwards branches", *quota));
         return false;
     }
     return true;
@@ -10249,6 +10307,12 @@ static IrInstruction *ir_const_bool(IrAnalyze *ira, IrInstruction *source_instru
     return result;
 }
 
+static IrInstruction *ir_const_undef(IrAnalyze *ira, IrInstruction *source_instruction, ZigType *ty) {
+    IrInstruction *result = ir_const(ira, source_instruction, ty);
+    result->value.special = ConstValSpecialUndef;
+    return result;
+}
+
 static IrInstruction *ir_const_void(IrAnalyze *ira, IrInstruction *source_instruction) {
     return ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_void);
 }
@@ -10295,7 +10359,7 @@ static ConstExprValue *ir_resolve_const(IrAnalyze *ira, IrInstruction *value, Un
 }
 
 ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
-        ZigType *expected_type, size_t *backward_branch_count, size_t backward_branch_quota,
+        ZigType *expected_type, size_t *backward_branch_count, size_t *backward_branch_quota,
         ZigFn *fn_entry, Buf *c_import_buf, AstNode *source_node, Buf *exec_name,
         IrExecutable *parent_exec, AstNode *expected_type_source_node)
 {
@@ -10317,7 +10381,7 @@ ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *nod
 
     if (codegen->verbose_ir) {
         fprintf(stderr, "\nSource: ");
-        ast_render(codegen, stderr, node, 4);
+        ast_render(stderr, node, 4);
         fprintf(stderr, "\n{ // (IR)\n");
         ir_print(codegen, stderr, ir_executable, 2);
         fprintf(stderr, "}\n");
@@ -10562,19 +10626,34 @@ static IrInstruction *ir_analyze_null_to_maybe(IrAnalyze *ira, IrInstruction *so
     assert(instr_is_comptime(value));
 
     ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
-    assert(val);
+    assert(val != nullptr);
 
-    IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb, source_instr->scope, source_instr->source_node);
-    const_instruction->base.value.special = ConstValSpecialStatic;
+    IrInstruction *result = ir_const(ira, source_instr, wanted_type);
+    result->value.special = ConstValSpecialStatic;
     if (get_codegen_ptr_type(wanted_type) != nullptr) {
-        const_instruction->base.value.data.x_ptr.special = ConstPtrSpecialNull;
+        result->value.data.x_ptr.special = ConstPtrSpecialNull;
     } else if (is_opt_err_set(wanted_type)) {
-        const_instruction->base.value.data.x_err_set = nullptr;
+        result->value.data.x_err_set = nullptr;
     } else {
-        const_instruction->base.value.data.x_optional = nullptr;
+        result->value.data.x_optional = nullptr;
     }
-    const_instruction->base.value.type = wanted_type;
-    return &const_instruction->base;
+    return result;
+}
+
+static IrInstruction *ir_analyze_null_to_c_pointer(IrAnalyze *ira, IrInstruction *source_instr,
+        IrInstruction *value, ZigType *wanted_type)
+{
+    assert(wanted_type->id == ZigTypeIdPointer);
+    assert(wanted_type->data.pointer.ptr_len == PtrLenC);
+    assert(instr_is_comptime(value));
+
+    ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
+    assert(val != nullptr);
+
+    IrInstruction *result = ir_const(ira, source_instr, wanted_type);
+    result->value.data.x_ptr.special = ConstPtrSpecialNull;
+    result->value.data.x_ptr.mut = ConstPtrMutComptimeConst;
+    return result;
 }
 
 static IrInstruction *ir_get_ref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *value,
@@ -11576,6 +11655,13 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         return ir_analyze_null_to_maybe(ira, source_instr, value, wanted_type);
     }
 
+    // cast from null literal to C pointer
+    if (wanted_type->id == ZigTypeIdPointer && wanted_type->data.pointer.ptr_len == PtrLenC &&
+        actual_type->id == ZigTypeIdNull)
+    {
+        return ir_analyze_null_to_c_pointer(ira, source_instr, value, wanted_type);
+    }
+
     // cast from [N]T to E![]const T
     if (wanted_type->id == ZigTypeIdErrorUnion &&
         is_slice(wanted_type->data.error_union.payload_type) &&
@@ -12193,14 +12279,12 @@ static IrInstruction *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *
 
     IrBinOp op_id = bin_op_instruction->op_id;
     bool is_equality_cmp = (op_id == IrBinOpCmpEq || op_id == IrBinOpCmpNotEq);
-    if (is_equality_cmp &&
+    if (is_equality_cmp && op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull) {
+        return ir_const_bool(ira, &bin_op_instruction->base, (op_id == IrBinOpCmpEq));
+    } else if (is_equality_cmp &&
         ((op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdOptional) ||
-        (op2->value.type->id == ZigTypeIdNull && op1->value.type->id == ZigTypeIdOptional) ||
-        (op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull)))
+        (op2->value.type->id == ZigTypeIdNull && op1->value.type->id == ZigTypeIdOptional)))
     {
-        if (op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull) {
-            return ir_const_bool(ira, &bin_op_instruction->base, (op_id == IrBinOpCmpEq));
-        }
         IrInstruction *maybe_op;
         if (op1->value.type->id == ZigTypeIdNull) {
             maybe_op = op2;
@@ -12230,9 +12314,48 @@ static IrInstruction *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *
         } else {
             return is_non_null;
         }
+    } else if (is_equality_cmp && 
+        ((op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdPointer &&
+            op2->value.type->data.pointer.ptr_len == PtrLenC) ||
+        (op2->value.type->id == ZigTypeIdNull && op1->value.type->id == ZigTypeIdPointer &&
+            op1->value.type->data.pointer.ptr_len == PtrLenC)))
+    {
+        IrInstruction *c_ptr_op;
+        if (op1->value.type->id == ZigTypeIdNull) {
+            c_ptr_op = op2;
+        } else if (op2->value.type->id == ZigTypeIdNull) {
+            c_ptr_op = op1;
+        } else {
+            zig_unreachable();
+        }
+        if (instr_is_comptime(c_ptr_op)) {
+            ConstExprValue *c_ptr_val = ir_resolve_const(ira, c_ptr_op, UndefOk);
+            if (!c_ptr_val)
+                return ira->codegen->invalid_instruction;
+            if (c_ptr_val->special == ConstValSpecialUndef)
+                return ir_const_undef(ira, &bin_op_instruction->base, ira->codegen->builtin_types.entry_bool);
+            bool is_null = c_ptr_val->data.x_ptr.special == ConstPtrSpecialNull ||
+                (c_ptr_val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr &&
+                    c_ptr_val->data.x_ptr.data.hard_coded_addr.addr == 0);
+            bool bool_result = (op_id == IrBinOpCmpEq) ? is_null : !is_null;
+            return ir_const_bool(ira, &bin_op_instruction->base, bool_result);
+        }
+        IrInstruction *is_non_null = ir_build_test_nonnull(&ira->new_irb, bin_op_instruction->base.scope,
+            source_node, c_ptr_op);
+        is_non_null->value.type = ira->codegen->builtin_types.entry_bool;
+
+        if (op_id == IrBinOpCmpEq) {
+            IrInstruction *result = ir_build_bool_not(&ira->new_irb, bin_op_instruction->base.scope,
+                bin_op_instruction->base.source_node, is_non_null);
+            result->value.type = ira->codegen->builtin_types.entry_bool;
+            return result;
+        } else {
+            return is_non_null;
+        }
     } else if (op1->value.type->id == ZigTypeIdNull || op2->value.type->id == ZigTypeIdNull) {
-        ir_add_error_node(ira, source_node, buf_sprintf("only optionals (not '%s') can compare to null",
-            buf_ptr(&(op1->value.type->id == ZigTypeIdNull ? op2->value.type->name : op1->value.type->name))));
+        ZigType *non_null_type = (op1->value.type->id == ZigTypeIdNull) ? op2->value.type : op1->value.type;
+        ir_add_error_node(ira, source_node, buf_sprintf("comparison of '%s' with null",
+            buf_ptr(&non_null_type->name)));
         return ira->codegen->invalid_instruction;
     }
 
@@ -13828,11 +13951,12 @@ IrInstruction *ir_get_implicit_allocator(IrAnalyze *ira, IrInstruction *source_i
     zig_unreachable();
 }
 
-static IrInstruction *ir_analyze_async_call(IrAnalyze *ira, IrInstructionCall *call_instruction, ZigFn *fn_entry, ZigType *fn_type,
-    IrInstruction *fn_ref, IrInstruction **casted_args, size_t arg_count, IrInstruction *async_allocator_inst)
+static IrInstruction *ir_analyze_async_call(IrAnalyze *ira, IrInstructionCall *call_instruction, ZigFn *fn_entry,
+        ZigType *fn_type, IrInstruction *fn_ref, IrInstruction **casted_args, size_t arg_count,
+        IrInstruction *async_allocator_inst)
 {
     Buf *realloc_field_name = buf_create_from_str(ASYNC_REALLOC_FIELD_NAME);
-    assert(async_allocator_inst->value.type->id == ZigTypeIdPointer);
+    ir_assert(async_allocator_inst->value.type->id == ZigTypeIdPointer, &call_instruction->base);
     ZigType *container_type = async_allocator_inst->value.type->data.pointer.child_type;
     IrInstruction *field_ptr_inst = ir_analyze_container_field_ptr(ira, realloc_field_name, &call_instruction->base,
             async_allocator_inst, container_type);
@@ -13840,7 +13964,7 @@ static IrInstruction *ir_analyze_async_call(IrAnalyze *ira, IrInstructionCall *c
         return ira->codegen->invalid_instruction;
     }
     ZigType *ptr_to_realloc_fn_type = field_ptr_inst->value.type;
-    assert(ptr_to_realloc_fn_type->id == ZigTypeIdPointer);
+    ir_assert(ptr_to_realloc_fn_type->id == ZigTypeIdPointer, &call_instruction->base);
 
     ZigType *realloc_fn_type = ptr_to_realloc_fn_type->data.pointer.child_type;
     if (realloc_fn_type->id != ZigTypeIdFn) {
@@ -13875,7 +13999,7 @@ static bool ir_analyze_fn_call_inline_arg(IrAnalyze *ira, AstNode *fn_proto_node
     IrInstruction *casted_arg;
     if (param_decl_node->data.param_decl.var_token == nullptr) {
         AstNode *param_type_node = param_decl_node->data.param_decl.type;
-        ZigType *param_type = analyze_type_expr(ira->codegen, *exec_scope, param_type_node);
+        ZigType *param_type = ir_analyze_type_expr(ira, *exec_scope, param_type_node);
         if (type_is_invalid(param_type))
             return false;
 
@@ -13915,7 +14039,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
     } else {
         if (param_decl_node->data.param_decl.var_token == nullptr) {
             AstNode *param_type_node = param_decl_node->data.param_decl.type;
-            ZigType *param_type = analyze_type_expr(ira->codegen, *child_scope, param_type_node);
+            ZigType *param_type = ir_analyze_type_expr(ira, *child_scope, param_type_node);
             if (type_is_invalid(param_type))
                 return false;
 
@@ -14296,7 +14420,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call
         }
 
         AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
-        ZigType *specified_return_type = analyze_type_expr(ira->codegen, exec_scope, return_type_node);
+        ZigType *specified_return_type = ir_analyze_type_expr(ira, exec_scope, return_type_node);
         if (type_is_invalid(specified_return_type))
             return ira->codegen->invalid_instruction;
         ZigType *return_type;
@@ -14532,7 +14656,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call
 
         if (fn_proto_node->data.fn_proto.return_var_token == nullptr) {
             AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
-            ZigType *specified_return_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, return_type_node);
+            ZigType *specified_return_type = ir_analyze_type_expr(ira, impl_fn->child_scope, return_type_node);
             if (type_is_invalid(specified_return_type))
                 return ira->codegen->invalid_instruction;
             if (fn_proto_node->data.fn_proto.auto_err_set) {
@@ -14559,7 +14683,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call
         if (call_instruction->is_async) {
             AstNode *async_allocator_type_node = fn_proto_node->data.fn_proto.async_allocator_type;
             if (async_allocator_type_node != nullptr) {
-                ZigType *async_allocator_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, async_allocator_type_node);
+                ZigType *async_allocator_type = ir_analyze_type_expr(ira, impl_fn->child_scope, async_allocator_type_node);
                 if (type_is_invalid(async_allocator_type))
                     return ira->codegen->invalid_instruction;
                 inst_fn_type_id.async_allocator_type = async_allocator_type;
@@ -15822,7 +15946,7 @@ static void add_link_lib_symbol(IrAnalyze *ira, Buf *lib_name, Buf *symbol_name,
         }
     }
 
-    if (!is_libc && !ira->codegen->have_pic && !ira->codegen->reported_bad_link_libc_error) {
+    if (!is_libc && !target_is_wasm(ira->codegen->zig_target) && !ira->codegen->have_pic && !ira->codegen->reported_bad_link_libc_error) {
         ErrorMsg *msg = ir_add_error_node(ira, source_node,
             buf_sprintf("dependency on dynamic library '%s' requires enabling Position Independent Code",
                 buf_ptr(lib_name)));
@@ -16696,16 +16820,16 @@ static IrInstruction *ir_analyze_instruction_size_of(IrAnalyze *ira,
         case ZigTypeIdUnreachable:
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
-        case ZigTypeIdComptimeFloat:
-        case ZigTypeIdComptimeInt:
-        case ZigTypeIdEnumLiteral:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdMetaType:
         case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
-            ir_add_error_node(ira, size_of_instruction->base.source_node,
+            ir_add_error_node(ira, type_value->source_node,
                     buf_sprintf("no size available for type '%s'", buf_ptr(&type_entry->name)));
             return ira->codegen->invalid_instruction;
+        case ZigTypeIdMetaType:
+        case ZigTypeIdEnumLiteral:
+        case ZigTypeIdComptimeFloat:
+        case ZigTypeIdComptimeInt:
         case ZigTypeIdVoid:
         case ZigTypeIdBool:
         case ZigTypeIdInt:
@@ -16732,11 +16856,30 @@ static IrInstruction *ir_analyze_instruction_size_of(IrAnalyze *ira,
 static IrInstruction *ir_analyze_test_non_null(IrAnalyze *ira, IrInstruction *source_inst, IrInstruction *value) {
     ZigType *type_entry = value->value.type;
 
-    if (type_entry->id == ZigTypeIdOptional) {
+    if (type_entry->id == ZigTypeIdPointer && type_entry->data.pointer.allow_zero) {
         if (instr_is_comptime(value)) {
-            ConstExprValue *maybe_val = ir_resolve_const(ira, value, UndefBad);
-            if (!maybe_val)
+            ConstExprValue *c_ptr_val = ir_resolve_const(ira, value, UndefOk);
+            if (c_ptr_val == nullptr)
+                return ira->codegen->invalid_instruction;
+            if (c_ptr_val->special == ConstValSpecialUndef)
+                return ir_const_undef(ira, source_inst, ira->codegen->builtin_types.entry_bool);
+            bool is_null = c_ptr_val->data.x_ptr.special == ConstPtrSpecialNull ||
+                (c_ptr_val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr &&
+                    c_ptr_val->data.x_ptr.data.hard_coded_addr.addr == 0);
+            return ir_const_bool(ira, source_inst, !is_null);
+        }
+
+        IrInstruction *result = ir_build_test_nonnull(&ira->new_irb,
+            source_inst->scope, source_inst->source_node, value);
+        result->value.type = ira->codegen->builtin_types.entry_bool;
+        return result;
+    } else if (type_entry->id == ZigTypeIdOptional) {
+        if (instr_is_comptime(value)) {
+            ConstExprValue *maybe_val = ir_resolve_const(ira, value, UndefOk);
+            if (maybe_val == nullptr)
                 return ira->codegen->invalid_instruction;
+            if (maybe_val->special == ConstValSpecialUndef)
+                return ir_const_undef(ira, source_inst, ira->codegen->builtin_types.entry_bool);
 
             return ir_const_bool(ira, source_inst, !optional_value_is_null(maybe_val));
         }
@@ -16770,6 +16913,32 @@ static IrInstruction *ir_analyze_unwrap_optional_payload(IrAnalyze *ira, IrInstr
     if (type_is_invalid(type_entry))
         return ira->codegen->invalid_instruction;
 
+    if (type_entry->id == ZigTypeIdPointer && type_entry->data.pointer.ptr_len == PtrLenC) {
+        if (instr_is_comptime(base_ptr)) {
+            ConstExprValue *val = ir_resolve_const(ira, base_ptr, UndefBad);
+            if (!val)
+                return ira->codegen->invalid_instruction;
+            if (val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
+                ConstExprValue *c_ptr_val = const_ptr_pointee(ira, ira->codegen, val, source_instr->source_node);
+                if (c_ptr_val == nullptr)
+                    return ira->codegen->invalid_instruction;
+                bool is_null = c_ptr_val->data.x_ptr.special == ConstPtrSpecialNull ||
+                    (c_ptr_val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr &&
+                        c_ptr_val->data.x_ptr.data.hard_coded_addr.addr == 0);
+                if (is_null) {
+                    ir_add_error(ira, source_instr, buf_sprintf("unable to unwrap null"));
+                    return ira->codegen->invalid_instruction;
+                }
+                return base_ptr;
+            }
+        }
+        if (!safety_check_on)
+            return base_ptr;
+        IrInstruction *c_ptr_val = ir_get_deref(ira, source_instr, base_ptr);
+        ir_build_assert_non_null(ira, source_instr, c_ptr_val);
+        return base_ptr;
+    }
+
     if (type_entry->id != ZigTypeIdOptional) {
         ir_add_error_node(ira, base_ptr->source_node,
                 buf_sprintf("expected optional type, found '%s'", buf_ptr(&type_entry->name)));
@@ -16784,11 +16953,11 @@ static IrInstruction *ir_analyze_unwrap_optional_payload(IrAnalyze *ira, IrInstr
         ConstExprValue *val = ir_resolve_const(ira, base_ptr, UndefBad);
         if (!val)
             return ira->codegen->invalid_instruction;
-        ConstExprValue *maybe_val = const_ptr_pointee(ira, ira->codegen, val, source_instr->source_node);
-        if (maybe_val == nullptr)
-            return ira->codegen->invalid_instruction;
-
         if (val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
+            ConstExprValue *maybe_val = const_ptr_pointee(ira, ira->codegen, val, source_instr->source_node);
+            if (maybe_val == nullptr)
+                return ira->codegen->invalid_instruction;
+
             if (optional_value_is_null(maybe_val)) {
                 ir_add_error(ira, source_instr, buf_sprintf("unable to unwrap null"));
                 return ira->codegen->invalid_instruction;
@@ -17435,6 +17604,7 @@ static IrInstruction *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruc
     ConstExprValue const_val = {};
     const_val.special = ConstValSpecialStatic;
     const_val.type = container_type;
+    // const_val.global_refs = allocate<ConstGlobalRefs>(1);
     const_val.data.x_struct.fields = create_const_vals(actual_field_count);
     for (size_t i = 0; i < instr_field_count; i += 1) {
         IrInstructionContainerInitFieldsField *field = &fields[i];
@@ -17498,7 +17668,7 @@ static IrInstruction *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruc
     if (const_val.special == ConstValSpecialStatic) {
         IrInstruction *result = ir_const(ira, instruction, nullptr);
         ConstExprValue *out_val = &result->value;
-        copy_const_val(out_val, &const_val, true);
+        copy_const_val(out_val, &const_val, false);
         out_val->type = container_type;
 
         for (size_t i = 0; i < instr_field_count; i += 1) {
@@ -17570,6 +17740,7 @@ static IrInstruction *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
         ConstExprValue const_val = {};
         const_val.special = ConstValSpecialStatic;
         const_val.type = fixed_size_array_type;
+        // const_val.global_refs = allocate<ConstGlobalRefs>(1);
         const_val.data.x_array.data.s_none.elements = create_const_vals(elem_count);
 
         bool is_comptime = ir_should_inline(ira->new_irb.exec, instruction->base.scope);
@@ -17606,8 +17777,6 @@ static IrInstruction *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
         if (const_val.special == ConstValSpecialStatic) {
             IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
             ConstExprValue *out_val = &result->value;
-            // Make sure to pass same_global_refs=false here in order not to
-            // zero the global_refs field for `result` (#1608)
             copy_const_val(out_val, &const_val, false);
             result->value.type = fixed_size_array_type;
             for (size_t i = 0; i < elem_count; i += 1) {
@@ -18961,8 +19130,8 @@ static IrInstruction *ir_analyze_instruction_set_eval_branch_quota(IrAnalyze *ir
     if (!ir_resolve_usize(ira, instruction->new_quota->child, &new_quota))
         return ira->codegen->invalid_instruction;
 
-    if (new_quota > ira->new_irb.exec->backward_branch_quota) {
-        ira->new_irb.exec->backward_branch_quota = new_quota;
+    if (new_quota > *ira->new_irb.exec->backward_branch_quota) {
+        *ira->new_irb.exec->backward_branch_quota = new_quota;
     }
 
     return ir_const_void(ira, &instruction->base);
@@ -19059,24 +19228,50 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct
             fprintf(stderr, "@cImport source: %s\n", buf_ptr(&tmp_c_file_path));
         }
 
-        ZigList<ErrorMsg *> errors = {0};
-
         Buf *tmp_dep_file = buf_sprintf("%s.d", buf_ptr(&tmp_c_file_path));
+
+        ZigList<const char *> clang_argv = {0};
+
+        add_cc_args(ira->codegen, clang_argv, buf_ptr(tmp_dep_file), true);
+
+        clang_argv.append(buf_ptr(&tmp_c_file_path));
+
+        if (ira->codegen->verbose_cc) {
+            fprintf(stderr, "clang");
+            for (size_t i = 0; i < clang_argv.length; i += 1) {
+                fprintf(stderr, " %s", clang_argv.at(i));
+            }
+            fprintf(stderr, "\n");
+        }
+
+        clang_argv.append(nullptr); // to make the [start...end] argument work
+
         AstNode *root_node;
-        if ((err = parse_h_file(&root_node, &errors, buf_ptr(&tmp_c_file_path), ira->codegen, tmp_dep_file))) {
+        Stage2ErrorMsg *errors_ptr;
+        size_t errors_len;
+
+        const char *resources_path = buf_ptr(ira->codegen->zig_c_headers_dir);
+
+        if ((err = parse_h_file(ira->codegen, &root_node, &errors_ptr, &errors_len,
+            &clang_argv.at(0), &clang_argv.last(), Stage2TranslateModeImport, resources_path)))
+        {
             if (err != ErrorCCompileErrors) {
                 ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));
                 return ira->codegen->invalid_instruction;
             }
-            assert(errors.length > 0);
 
             ErrorMsg *parent_err_msg = ir_add_error_node(ira, node, buf_sprintf("C import failed"));
             if (ira->codegen->libc_link_lib == nullptr) {
                 add_error_note(ira->codegen, parent_err_msg, node,
                     buf_sprintf("libc headers not available; compilation does not link against libc"));
             }
-            for (size_t i = 0; i < errors.length; i += 1) {
-                ErrorMsg *err_msg = errors.at(i);
+            for (size_t i = 0; i < errors_len; i += 1) {
+                Stage2ErrorMsg *clang_err = &errors_ptr[i];
+                ErrorMsg *err_msg = err_msg_create_with_offset(
+                    clang_err->filename_ptr ?
+                        buf_create_from_mem(clang_err->filename_ptr, clang_err->filename_len) : buf_alloc(),
+                    clang_err->line, clang_err->column, clang_err->offset, clang_err->source,
+                    buf_create_from_mem(clang_err->msg_ptr, clang_err->msg_len));
                 err_msg_add_note(parent_err_msg, err_msg);
             }
 
@@ -19106,7 +19301,7 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct
                     buf_sprintf("C import failed: unable to open output file: %s", strerror(errno)));
             return ira->codegen->invalid_instruction;
         }
-        ast_render(ira->codegen, out_file, root_node, 4);
+        ast_render(out_file, root_node, 4);
         if (fclose(out_file) != 0) {
             ir_add_error_node(ira, node,
                     buf_sprintf("C import failed: unable to write to output file: %s", strerror(errno)));
@@ -21026,18 +21221,24 @@ static IrInstruction *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
         for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
             IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
 
-            IrInstruction *start_value = range->start->child;
+            IrInstruction *start_value_uncasted = range->start->child;
+            if (type_is_invalid(start_value_uncasted->value.type))
+                return ira->codegen->invalid_instruction;
+            IrInstruction *start_value = ir_implicit_cast(ira, start_value_uncasted, switch_type);
             if (type_is_invalid(start_value->value.type))
                 return ira->codegen->invalid_instruction;
 
-            IrInstruction *end_value = range->end->child;
+            IrInstruction *end_value_uncasted = range->end->child;
+            if (type_is_invalid(end_value_uncasted->value.type))
+                return ira->codegen->invalid_instruction;
+            IrInstruction *end_value = ir_implicit_cast(ira, end_value_uncasted, switch_type);
             if (type_is_invalid(end_value->value.type))
                 return ira->codegen->invalid_instruction;
 
-            assert(start_value->value.type->id == ZigTypeIdErrorSet);
+            ir_assert(start_value->value.type->id == ZigTypeIdErrorSet, &instruction->base);
             uint32_t start_index = start_value->value.data.x_err_set->value;
 
-            assert(end_value->value.type->id == ZigTypeIdErrorSet);
+            ir_assert(end_value->value.type->id == ZigTypeIdErrorSet, &instruction->base);
             uint32_t end_index = end_value->value.data.x_err_set->value;
 
             if (start_index != end_index) {
@@ -21260,7 +21461,7 @@ static IrInstruction *ir_align_cast(IrAnalyze *ira, IrInstruction *target, uint3
         }
 
         IrInstruction *result = ir_const(ira, target, result_type);
-        copy_const_val(&result->value, val, false);
+        copy_const_val(&result->value, val, true);
         result->value.type = result_type;
         return result;
     }
@@ -21330,7 +21531,7 @@ static IrInstruction *ir_analyze_ptr_cast(IrAnalyze *ira, IrInstruction *source_
         }
 
         IrInstruction *result = ir_const(ira, source_instr, dest_type);
-        copy_const_val(&result->value, val, false);
+        copy_const_val(&result->value, val, true);
         result->value.type = dest_type;
 
         // Keep the bigger alignment, it can only help-
@@ -21562,7 +21763,7 @@ static Error buf_read_value_bytes_array(IrAnalyze *ira, CodeGen *codegen, AstNod
 
 static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *source_node, uint8_t *buf, ConstExprValue *val) {
     Error err;
-    assert(val->special == ConstValSpecialStatic);
+    src_assert(val->special == ConstValSpecialStatic, source_node);
     switch (val->type->id) {
         case ZigTypeIdInvalid:
         case ZigTypeIdMetaType:
@@ -21612,7 +21813,7 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou
                     zig_panic("TODO buf_read_value_bytes enum packed");
                 case ContainerLayoutExtern: {
                     ZigType *tag_int_type = val->type->data.enumeration.tag_int_type;
-                    assert(tag_int_type->id == ZigTypeIdInt);
+                    src_assert(tag_int_type->id == ZigTypeIdInt, source_node);
                     bigint_read_twos_complement(&val->data.x_enum_tag, buf, tag_int_type->data.integral.bit_count,
                             codegen->is_big_endian, tag_int_type->data.integral.is_signed);
                     return ErrorNone;
@@ -21667,7 +21868,7 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou
                         bigint_read_twos_complement(&big_int, buf + offset, big_int_byte_count * 8, is_big_endian, false);
                         while (src_i < src_field_count) {
                             TypeStructField *field = &val->type->data.structure.fields[src_i];
-                            assert(field->gen_index != SIZE_MAX);
+                            src_assert(field->gen_index != SIZE_MAX, source_node);
                             if (field->gen_index != gen_i)
                                 break;
                             ConstExprValue *field_val = &val->data.x_struct.fields[src_i];
@@ -21743,10 +21944,10 @@ static IrInstruction *ir_analyze_bit_cast(IrAnalyze *ira, IrInstruction *source_
     Error err;
 
     ZigType *src_type = value->value.type;
-    assert(get_codegen_ptr_type(src_type) == nullptr);
-    assert(type_can_bit_cast(src_type));
-    assert(get_codegen_ptr_type(dest_type) == nullptr);
-    assert(type_can_bit_cast(dest_type));
+    ir_assert(get_codegen_ptr_type(src_type) == nullptr, source_instr);
+    ir_assert(type_can_bit_cast(src_type), source_instr);
+    ir_assert(get_codegen_ptr_type(dest_type) == nullptr, source_instr);
+    ir_assert(type_can_bit_cast(dest_type), source_instr);
 
     if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusSizeKnown)))
         return ira->codegen->invalid_instruction;
@@ -21836,8 +22037,8 @@ static IrInstruction *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstruct
 static IrInstruction *ir_analyze_int_to_ptr(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *target,
         ZigType *ptr_type)
 {
-    assert(get_src_ptr_type(ptr_type) != nullptr);
-    assert(type_has_bits(ptr_type));
+    ir_assert(get_src_ptr_type(ptr_type) != nullptr, source_instr);
+    ir_assert(type_has_bits(ptr_type), source_instr);
 
     IrInstruction *casted_int = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_usize);
     if (type_is_invalid(casted_int->value.type))
@@ -21936,7 +22137,7 @@ static IrInstruction *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
         case TldIdFn: {
             TldFn *tld_fn = (TldFn *)tld;
             ZigFn *fn_entry = tld_fn->fn_entry;
-            assert(fn_entry->type_entry);
+            ir_assert(fn_entry->type_entry, &instruction->base);
 
             if (tld_fn->extern_lib_name != nullptr) {
                 add_link_lib_symbol(ira, tld_fn->extern_lib_name, &fn_entry->symbol_name, instruction->base.source_node);
@@ -22134,7 +22335,7 @@ static IrInstruction *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstruct
     ZigType *result_type = fn_type_id->param_info[arg_index].type;
     if (result_type == nullptr) {
         // Args are only unresolved if our function is generic.
-        assert(fn_type->data.fn.is_generic);
+        ir_assert(fn_type->data.fn.is_generic, &instruction->base);
 
         ir_add_error(ira, arg_index_inst,
             buf_sprintf("@ArgType could not resolve the type of arg %" ZIG_PRI_u64 " because '%s' is generic",
@@ -22220,7 +22421,7 @@ static IrInstruction *ir_analyze_instruction_coro_begin(IrAnalyze *ira, IrInstru
         return ira->codegen->invalid_instruction;
 
     ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
-    assert(fn_entry != nullptr);
+    ir_assert(fn_entry != nullptr, &instruction->base);
     IrInstruction *result = ir_build_coro_begin(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
             coro_id, coro_mem_ptr);
     result->value.type = get_promise_type(ira->codegen, fn_entry->type_entry->data.fn.fn_type_id.return_type);
@@ -22458,7 +22659,7 @@ static IrInstruction *ir_analyze_instruction_atomic_load(IrAnalyze *ira, IrInstr
     }
 
     if (ordering == AtomicOrderRelease || ordering == AtomicOrderAcqRel) {
-        assert(instruction->ordering != nullptr);
+        ir_assert(instruction->ordering != nullptr, &instruction->base);
         ir_add_error(ira, instruction->ordering,
             buf_sprintf("@atomicLoad atomic ordering must not be Release or AcqRel"));
         return ira->codegen->invalid_instruction;
@@ -22466,7 +22667,7 @@ static IrInstruction *ir_analyze_instruction_atomic_load(IrAnalyze *ira, IrInstr
 
     if (instr_is_comptime(casted_ptr)) {
         IrInstruction *result = ir_get_deref(ira, &instruction->base, casted_ptr);
-        assert(result->value.type != nullptr);
+        ir_assert(result->value.type != nullptr, &instruction->base);
         return result;
     }
 
@@ -22496,7 +22697,7 @@ static IrInstruction *ir_analyze_instruction_await_bookkeeping(IrAnalyze *ira, I
         return ira->codegen->invalid_instruction;
 
     ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
-    assert(fn_entry != nullptr);
+    ir_assert(fn_entry != nullptr, &instruction->base);
 
     if (type_can_fail(promise_result_type)) {
         fn_entry->calls_or_awaits_errorable_fn = true;
@@ -22512,9 +22713,9 @@ static IrInstruction *ir_analyze_instruction_merge_err_ret_traces(IrAnalyze *ira
     if (type_is_invalid(coro_promise_ptr->value.type))
         return ira->codegen->invalid_instruction;
 
-    assert(coro_promise_ptr->value.type->id == ZigTypeIdPointer);
+    ir_assert(coro_promise_ptr->value.type->id == ZigTypeIdPointer, &instruction->base);
     ZigType *promise_frame_type = coro_promise_ptr->value.type->data.pointer.child_type;
-    assert(promise_frame_type->id == ZigTypeIdStruct);
+    ir_assert(promise_frame_type->id == ZigTypeIdStruct, &instruction->base);
     ZigType *promise_result_type = promise_frame_type->data.structure.fields[1].type_entry;
 
     if (!type_can_fail(promise_result_type)) {
@@ -22606,7 +22807,7 @@ static IrInstruction *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionS
         return result;
     }
 
-    assert(float_type->id == ZigTypeIdFloat);
+    ir_assert(float_type->id == ZigTypeIdFloat, &instruction->base);
     if (float_type->data.floating.bit_count != 16 &&
         float_type->data.floating.bit_count != 32 &&
         float_type->data.floating.bit_count != 64) {
@@ -22817,6 +23018,7 @@ static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructio
         case IrInstructionIdArrayToVector:
         case IrInstructionIdVectorToArray:
         case IrInstructionIdAssertZero:
+        case IrInstructionIdAssertNonNull:
         case IrInstructionIdResizeSlice:
         case IrInstructionIdLoadPtrGen:
         case IrInstructionIdBitCastGen:
@@ -23096,7 +23298,7 @@ static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructio
 
 static IrInstruction *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *old_instruction) {
     IrInstruction *new_instruction = ir_analyze_instruction_nocast(ira, old_instruction);
-    assert(new_instruction->value.type != nullptr);
+    ir_assert(new_instruction->value.type != nullptr, old_instruction);
     old_instruction->child = new_instruction;
     return new_instruction;
 }
@@ -23221,6 +23423,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdCmpxchgGen:
         case IrInstructionIdCmpxchgSrc:
         case IrInstructionIdAssertZero:
+        case IrInstructionIdAssertNonNull:
         case IrInstructionIdResizeSlice:
         case IrInstructionIdGlobalAsm:
             return true;
diff --git a/src/ir.hpp b/src/ir.hpp
index 0b85ad2c55..4fb7552212 100644
--- a/src/ir.hpp
+++ b/src/ir.hpp
@@ -14,7 +14,7 @@ bool ir_gen(CodeGen *g, AstNode *node, Scope *scope, IrExecutable *ir_executable
 bool ir_gen_fn(CodeGen *g, ZigFn *fn_entry);
 
 ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
-        ZigType *expected_type, size_t *backward_branch_count, size_t backward_branch_quota,
+        ZigType *expected_type, size_t *backward_branch_count, size_t *backward_branch_quota,
         ZigFn *fn_entry, Buf *c_import_buf, AstNode *source_node, Buf *exec_name,
         IrExecutable *parent_exec, AstNode *expected_type_source_node);
 
diff --git a/src/ir_print.cpp b/src/ir_print.cpp
index dba0e4ee00..08f5cd01a4 100644
--- a/src/ir_print.cpp
+++ b/src/ir_print.cpp
@@ -1003,6 +1003,12 @@ static void ir_print_assert_zero(IrPrint *irp, IrInstructionAssertZero *instruct
     fprintf(irp->f, ")");
 }
 
+static void ir_print_assert_non_null(IrPrint *irp, IrInstructionAssertNonNull *instruction) {
+    fprintf(irp->f, "AssertNonNull(");
+    ir_print_other_instruction(irp, instruction->target);
+    fprintf(irp->f, ")");
+}
+
 static void ir_print_resize_slice(IrPrint *irp, IrInstructionResizeSlice *instruction) {
     fprintf(irp->f, "@resizeSlice(");
     ir_print_other_instruction(irp, instruction->operand);
@@ -1880,6 +1886,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
         case IrInstructionIdAssertZero:
             ir_print_assert_zero(irp, (IrInstructionAssertZero *)instruction);
             break;
+        case IrInstructionIdAssertNonNull:
+            ir_print_assert_non_null(irp, (IrInstructionAssertNonNull *)instruction);
+            break;
         case IrInstructionIdResizeSlice:
             ir_print_resize_slice(irp, (IrInstructionResizeSlice *)instruction);
             break;
diff --git a/src/libc_installation.cpp b/src/libc_installation.cpp
index 3ea17f1bdc..fc51fa427e 100644
--- a/src/libc_installation.cpp
+++ b/src/libc_installation.cpp
@@ -14,6 +14,7 @@ static const char *zig_libc_keys[] = {
     "include_dir",
     "sys_include_dir",
     "crt_dir",
+    "static_crt_dir",
     "msvc_lib_dir",
     "kernel32_lib_dir",
 };
@@ -34,6 +35,7 @@ static void zig_libc_init_empty(ZigLibCInstallation *libc) {
     buf_init_from_str(&libc->include_dir, "");
     buf_init_from_str(&libc->sys_include_dir, "");
     buf_init_from_str(&libc->crt_dir, "");
+    buf_init_from_str(&libc->static_crt_dir, "");
     buf_init_from_str(&libc->msvc_lib_dir, "");
     buf_init_from_str(&libc->kernel32_lib_dir, "");
 }
@@ -45,7 +47,7 @@ Error zig_libc_parse(ZigLibCInstallation *libc, Buf *libc_file, const ZigTarget
     bool found_keys[array_length(zig_libc_keys)] = {};
 
     Buf *contents = buf_alloc();
-    if ((err = os_fetch_file_path(libc_file, contents, false))) {
+    if ((err = os_fetch_file_path(libc_file, contents))) {
         if (err != ErrorFileNotFound && verbose) {
             fprintf(stderr, "Unable to read '%s': %s\n", buf_ptr(libc_file), err_str(err));
         }
@@ -74,8 +76,9 @@ Error zig_libc_parse(ZigLibCInstallation *libc, Buf *libc_file, const ZigTarget
         match = match || zig_libc_match_key(name, value, found_keys, 0, &libc->include_dir);
         match = match || zig_libc_match_key(name, value, found_keys, 1, &libc->sys_include_dir);
         match = match || zig_libc_match_key(name, value, found_keys, 2, &libc->crt_dir);
-        match = match || zig_libc_match_key(name, value, found_keys, 3, &libc->msvc_lib_dir);
-        match = match || zig_libc_match_key(name, value, found_keys, 4, &libc->kernel32_lib_dir);
+        match = match || zig_libc_match_key(name, value, found_keys, 3, &libc->static_crt_dir);
+        match = match || zig_libc_match_key(name, value, found_keys, 4, &libc->msvc_lib_dir);
+        match = match || zig_libc_match_key(name, value, found_keys, 5, &libc->kernel32_lib_dir);
     }
 
     for (size_t i = 0; i < zig_libc_keys_len; i += 1) {
@@ -110,6 +113,15 @@ Error zig_libc_parse(ZigLibCInstallation *libc, Buf *libc_file, const ZigTarget
         }
     }
 
+    if (buf_len(&libc->static_crt_dir) == 0) {
+        if (target->os == OsWindows && target_abi_is_gnu(target->abi)) {
+            if (verbose) {
+                fprintf(stderr, "static_crt_dir may not be empty for %s\n", target_os_name(target->os));
+            }
+            return ErrorSemanticAnalyzeFail;
+        }
+    }
+
     if (buf_len(&libc->msvc_lib_dir) == 0) {
         if (target->os == OsWindows && !target_abi_is_gnu(target->abi)) {
             if (verbose) {
@@ -311,6 +323,10 @@ static Error zig_libc_find_native_crt_dir_posix(ZigLibCInstallation *self, bool
 #endif
 
 #if defined(ZIG_OS_WINDOWS)
+static Error zig_libc_find_native_static_crt_dir_posix(ZigLibCInstallation *self, bool verbose) {
+    return zig_libc_cc_print_file_name("crtbegin.o", &self->static_crt_dir, true, verbose);
+}
+
 static Error zig_libc_find_native_include_dir_windows(ZigLibCInstallation *self, ZigWindowsSDK *sdk, bool verbose) {
     Error err;
     if ((err = os_get_win32_ucrt_include_path(sdk, &self->include_dir))) {
@@ -322,7 +338,7 @@ static Error zig_libc_find_native_include_dir_windows(ZigLibCInstallation *self,
     return ErrorNone;
 }
 
-static Error zig_libc_find_crt_dir_windows(ZigLibCInstallation *self, ZigWindowsSDK *sdk, ZigTarget *target,
+static Error zig_libc_find_native_crt_dir_windows(ZigLibCInstallation *self, ZigWindowsSDK *sdk, ZigTarget *target,
         bool verbose)
 {
     Error err;
@@ -398,11 +414,16 @@ void zig_libc_render(ZigLibCInstallation *self, FILE *file) {
         "# On POSIX it's the directory that includes `sys/errno.h`.\n"
         "sys_include_dir=%s\n"
         "\n"
-        "# The directory that contains `crt1.o`.\n"
+        "# The directory that contains `crt1.o` or `crt2.o`.\n"
         "# On POSIX, can be found with `cc -print-file-name=crt1.o`.\n"
         "# Not needed when targeting MacOS.\n"
         "crt_dir=%s\n"
         "\n"
+        "# The directory that contains `crtbegin.o`.\n"
+        "# On POSIX, can be found with `cc -print-file-name=crtbegin.o`.\n"
+        "# Not needed when targeting MacOS.\n"
+        "static_crt_dir=%s\n"
+        "\n"
         "# The directory that contains `vcruntime.lib`.\n"
         "# Only needed when targeting MSVC on Windows.\n"
         "msvc_lib_dir=%s\n"
@@ -415,6 +436,7 @@ void zig_libc_render(ZigLibCInstallation *self, FILE *file) {
         buf_ptr(&self->include_dir),
         buf_ptr(&self->sys_include_dir),
         buf_ptr(&self->crt_dir),
+        buf_ptr(&self->static_crt_dir),
         buf_ptr(&self->msvc_lib_dir),
         buf_ptr(&self->kernel32_lib_dir)
     );
@@ -431,6 +453,8 @@ Error zig_libc_find_native(ZigLibCInstallation *self, bool verbose) {
             return err;
         if ((err = zig_libc_find_native_crt_dir_posix(self, verbose)))
             return err;
+        if ((err = zig_libc_find_native_static_crt_dir_posix(self, verbose)))
+            return err;
         return ErrorNone;
     } else {
         ZigWindowsSDK *sdk;
@@ -444,7 +468,7 @@ Error zig_libc_find_native(ZigLibCInstallation *self, bool verbose) {
                     return err;
                 if ((err = zig_libc_find_native_include_dir_windows(self, sdk, verbose)))
                     return err;
-                if ((err = zig_libc_find_crt_dir_windows(self, sdk, &native_target, verbose)))
+                if ((err = zig_libc_find_native_crt_dir_windows(self, sdk, &native_target, verbose)))
                     return err;
                 return ErrorNone;
             case ZigFindWindowsSdkErrorOutOfMemory:
diff --git a/src/libc_installation.hpp b/src/libc_installation.hpp
index 765ae4ec56..8ecad7ce61 100644
--- a/src/libc_installation.hpp
+++ b/src/libc_installation.hpp
@@ -19,6 +19,7 @@ struct ZigLibCInstallation {
     Buf include_dir;
     Buf sys_include_dir;
     Buf crt_dir;
+    Buf static_crt_dir;
     Buf msvc_lib_dir;
     Buf kernel32_lib_dir;
 };
@@ -29,8 +30,6 @@ void zig_libc_render(ZigLibCInstallation *self, FILE *file);
 
 Error ATTRIBUTE_MUST_USE zig_libc_find_native(ZigLibCInstallation *self, bool verbose);
 
-#if defined(ZIG_OS_LINUX) || defined(ZIG_OS_WINDOWS)
 Error zig_libc_cc_print_file_name(const char *o_file, Buf *out, bool want_dirname, bool verbose);
-#endif
 
 #endif
diff --git a/src/link.cpp b/src/link.cpp
index d6093581f7..8900d0351b 100644
--- a/src/link.cpp
+++ b/src/link.cpp
@@ -25,6 +25,7 @@ static CodeGen *create_child_codegen(CodeGen *parent_gen, Buf *root_src_path, Ou
     CodeGen *child_gen = codegen_create(nullptr, root_src_path, parent_gen->zig_target, out_type,
         parent_gen->build_mode, parent_gen->zig_lib_dir, parent_gen->zig_std_dir, libc, get_stage1_cache_path());
     child_gen->disable_gen_h = true;
+    child_gen->disable_stack_probing = true;
     child_gen->verbose_tokenize = parent_gen->verbose_tokenize;
     child_gen->verbose_ast = parent_gen->verbose_ast;
     child_gen->verbose_link = parent_gen->verbose_link;
@@ -772,17 +773,15 @@ static const char *get_libc_crt_file(CodeGen *parent, const char *file) {
     }
 }
 
-static Buf *build_a_raw(CodeGen *parent_gen, const char *aname, Buf *full_path) {
+static Buf *build_a_raw(CodeGen *parent_gen, const char *aname, Buf *full_path, OutType child_out_type) {
     // The Mach-O LLD code is not well maintained, and trips an assertion
     // when we link compiler_rt and builtin as libraries rather than objects.
     // Here we workaround this by having compiler_rt and builtin be objects.
     // TODO write our own linker. https://github.com/ziglang/zig/issues/1535
-    OutType child_out_type = OutTypeLib;
     if (parent_gen->zig_target->os == OsMacOSX) {
         child_out_type = OutTypeObj;
     }
 
-
     CodeGen *child_gen = create_child_codegen(parent_gen, full_path, child_out_type,
             parent_gen->libc);
     codegen_set_out_name(child_gen, buf_create_from_str(aname));
@@ -804,14 +803,14 @@ static Buf *build_a(CodeGen *parent_gen, const char *aname) {
     Buf *full_path = buf_alloc();
     os_path_join(parent_gen->zig_std_special_dir, source_basename, full_path);
 
-    return build_a_raw(parent_gen, aname, full_path);
+    return build_a_raw(parent_gen, aname, full_path, OutTypeLib);
 }
 
-static Buf *build_compiler_rt(CodeGen *parent_gen) {
+static Buf *build_compiler_rt(CodeGen *parent_gen, OutType child_out_type) {
     Buf *full_path = buf_alloc();
     os_path_join(parent_gen->zig_std_special_dir, buf_create_from_str("compiler_rt.zig"), full_path);
 
-    return build_a_raw(parent_gen, "compiler_rt", full_path);
+    return build_a_raw(parent_gen, "compiler_rt", full_path, child_out_type);
 }
 
 static const char *get_darwin_arch_string(const ZigTarget *t) {
@@ -1006,7 +1005,7 @@ static void construct_linker_job_elf(LinkJob *lj) {
             lj->args.append(buf_ptr(builtin_a_path));
         }
 
-        Buf *compiler_rt_o_path = build_compiler_rt(g);
+        Buf *compiler_rt_o_path = build_compiler_rt(g, OutTypeLib);
         lj->args.append(buf_ptr(compiler_rt_o_path));
     }
 
@@ -1091,16 +1090,35 @@ static void construct_linker_job_wasm(LinkJob *lj) {
     CodeGen *g = lj->codegen;
 
     lj->args.append("-error-limit=0");
-    lj->args.append("--no-entry");  // So lld doesn't look for _start.
+
+    if (g->zig_target->os != OsWASI) {
+	    lj->args.append("--no-entry");  // So lld doesn't look for _start.
+    }
     lj->args.append("--allow-undefined");
-    lj->args.append("--export-all");
     lj->args.append("-o");
     lj->args.append(buf_ptr(&g->output_file_path));
 
+    auto export_it = g->exported_symbol_names.entry_iterator();
+    decltype(g->exported_symbol_names)::Entry *curr_entry = nullptr;
+    while ((curr_entry = export_it.next()) != nullptr) {
+        Buf *arg = buf_sprintf("--export=%s", buf_ptr(curr_entry->key));
+        lj->args.append(buf_ptr(arg));
+    }
+
     // .o files
     for (size_t i = 0; i < g->link_objects.length; i += 1) {
         lj->args.append((const char *)buf_ptr(g->link_objects.at(i)));
     }
+
+    if (g->out_type == OutTypeExe) {
+        if (g->libc_link_lib == nullptr) {
+            Buf *builtin_a_path = build_a(g, "builtin");
+            lj->args.append(buf_ptr(builtin_a_path));
+        }
+
+        Buf *compiler_rt_o_path = build_compiler_rt(g, OutTypeLib);
+        lj->args.append(buf_ptr(compiler_rt_o_path));
+    }
 }
 
 static void coff_append_machine_arg(CodeGen *g, ZigList<const char *> *list) {
@@ -1124,53 +1142,121 @@ static bool zig_lld_link(ZigLLVM_ObjectFormatType oformat, const char **args, si
 }
 
 static void add_uefi_link_args(LinkJob *lj) {
-    lj->args.append("/BASE:0");
-    lj->args.append("/ENTRY:EfiMain");
-    lj->args.append("/OPT:REF");
-    lj->args.append("/SAFESEH:NO");
-    lj->args.append("/MERGE:.rdata=.data");
-    lj->args.append("/ALIGN:32");
-    lj->args.append("/NODEFAULTLIB");
-    lj->args.append("/SECTION:.xdata,D");
+    lj->args.append("-BASE:0");
+    lj->args.append("-ENTRY:EfiMain");
+    lj->args.append("-OPT:REF");
+    lj->args.append("-SAFESEH:NO");
+    lj->args.append("-MERGE:.rdata=.data");
+    lj->args.append("-ALIGN:32");
+    lj->args.append("-NODEFAULTLIB");
+    lj->args.append("-SECTION:.xdata,D");
 }
 
-static void add_nt_link_args(LinkJob *lj, bool is_library) {
+static void add_msvc_link_args(LinkJob *lj, bool is_library) {
     CodeGen *g = lj->codegen;
 
-    if (lj->link_in_crt) {
-        // TODO: https://github.com/ziglang/zig/issues/2064
-        bool is_dynamic = true; // g->is_dynamic;
-        const char *lib_str = is_dynamic ? "" : "lib";
-        const char *d_str = (g->build_mode == BuildModeDebug) ? "d" : "";
-
-        if (!is_dynamic) {
-            Buf *cmt_lib_name = buf_sprintf("libcmt%s.lib", d_str);
-            lj->args.append(buf_ptr(cmt_lib_name));
-        } else {
-            Buf *msvcrt_lib_name = buf_sprintf("msvcrt%s.lib", d_str);
-            lj->args.append(buf_ptr(msvcrt_lib_name));
-        }
+    // TODO: https://github.com/ziglang/zig/issues/2064
+    bool is_dynamic = true; // g->is_dynamic;
+    const char *lib_str = is_dynamic ? "" : "lib";
+    const char *d_str = (g->build_mode == BuildModeDebug) ? "d" : "";
+
+    if (!is_dynamic) {
+        Buf *cmt_lib_name = buf_sprintf("libcmt%s.lib", d_str);
+        lj->args.append(buf_ptr(cmt_lib_name));
+    } else {
+        Buf *msvcrt_lib_name = buf_sprintf("msvcrt%s.lib", d_str);
+        lj->args.append(buf_ptr(msvcrt_lib_name));
+    }
+
+    Buf *vcruntime_lib_name = buf_sprintf("%svcruntime%s.lib", lib_str, d_str);
+    lj->args.append(buf_ptr(vcruntime_lib_name));
 
-        Buf *vcruntime_lib_name = buf_sprintf("%svcruntime%s.lib", lib_str, d_str);
-        lj->args.append(buf_ptr(vcruntime_lib_name));
+    Buf *crt_lib_name = buf_sprintf("%sucrt%s.lib", lib_str, d_str);
+    lj->args.append(buf_ptr(crt_lib_name));
 
-        Buf *crt_lib_name = buf_sprintf("%sucrt%s.lib", lib_str, d_str);
-        lj->args.append(buf_ptr(crt_lib_name));
+    //Visual C++ 2015 Conformance Changes
+    //https://msdn.microsoft.com/en-us/library/bb531344.aspx
+    lj->args.append("legacy_stdio_definitions.lib");
 
-        //Visual C++ 2015 Conformance Changes
-        //https://msdn.microsoft.com/en-us/library/bb531344.aspx
-        lj->args.append("legacy_stdio_definitions.lib");
+    // msvcrt depends on kernel32 and ntdll
+    lj->args.append("kernel32.lib");
+    lj->args.append("ntdll.lib");
+}
+
+static const char *get_libc_file(ZigLibCInstallation *lib, const char *file) {
+    Buf *out_buf = buf_alloc();
+    os_path_join(&lib->crt_dir, buf_create_from_str(file), out_buf);
+    return buf_ptr(out_buf);
+}
+
+static const char *get_libc_static_file(ZigLibCInstallation *lib, const char *file) {
+    Buf *out_buf = buf_alloc();
+    os_path_join(&lib->static_crt_dir, buf_create_from_str(file), out_buf);
+    return buf_ptr(out_buf);
+}
+
+static void add_mingw_link_args(LinkJob *lj, bool is_library) {
+    CodeGen *g = lj->codegen;
 
-        // msvcrt depends on kernel32 and ntdll
-        lj->args.append("kernel32.lib");
-        lj->args.append("ntdll.lib");
+    bool is_dll = g->out_type == OutTypeLib && g->is_dynamic;
+
+    if (g->zig_target->arch == ZigLLVM_x86) {
+        lj->args.append("-ALTERNATENAME:__image_base__=___ImageBase");
+    } else {
+        lj->args.append("-ALTERNATENAME:__image_base__=__ImageBase");
+    }
+
+    if (is_dll) {
+       lj->args.append(get_libc_file(g->libc, "dllcrt2.o"));
+    } else {
+       lj->args.append(get_libc_file(g->libc, "crt2.o"));
+    }
+
+    lj->args.append(get_libc_static_file(g->libc, "crtbegin.o"));
+
+    lj->args.append(get_libc_file(g->libc, "libmingw32.a"));
+
+    if (is_dll) {
+        lj->args.append(get_libc_static_file(g->libc, "libgcc_s.a"));
+        lj->args.append(get_libc_static_file(g->libc, "libgcc.a"));
+    } else {
+        lj->args.append(get_libc_static_file(g->libc, "libgcc.a"));
+        lj->args.append(get_libc_static_file(g->libc, "libgcc_eh.a"));
+    }
+
+    lj->args.append(get_libc_static_file(g->libc, "libssp.a"));
+    lj->args.append(get_libc_file(g->libc, "libmoldname.a"));
+    lj->args.append(get_libc_file(g->libc, "libmingwex.a"));
+    lj->args.append(get_libc_file(g->libc, "libmsvcrt.a"));
+
+    if (g->subsystem == TargetSubsystemWindows) {
+        lj->args.append(get_libc_file(g->libc, "libgdi32.a"));
+        lj->args.append(get_libc_file(g->libc, "libcomdlg32.a"));
+    }
+
+    lj->args.append(get_libc_file(g->libc, "libadvapi32.a"));
+    lj->args.append(get_libc_file(g->libc, "libadvapi32.a"));
+    lj->args.append(get_libc_file(g->libc, "libshell32.a"));
+    lj->args.append(get_libc_file(g->libc, "libuser32.a"));
+    lj->args.append(get_libc_file(g->libc, "libkernel32.a"));
+
+    lj->args.append(get_libc_static_file(g->libc, "crtend.o"));
+}
+
+static void add_win_link_args(LinkJob *lj, bool is_library) {
+    if (lj->link_in_crt) {
+        if (target_abi_is_gnu(lj->codegen->zig_target->abi)) {
+            add_mingw_link_args(lj, is_library);
+        } else {
+            add_msvc_link_args(lj, is_library);
+        }
     } else {
-        lj->args.append("/NODEFAULTLIB");
+        lj->args.append("-NODEFAULTLIB");
         if (!is_library) {
-            if (g->have_winmain) {
-                lj->args.append("/ENTRY:WinMain");
+            if (lj->codegen->have_winmain) {
+                lj->args.append("-ENTRY:WinMain");
             } else {
-                lj->args.append("/ENTRY:WinMainCRTStartup");
+                lj->args.append("-ENTRY:WinMainCRTStartup");
             }
         }
     }
@@ -1180,87 +1266,93 @@ static void construct_linker_job_coff(LinkJob *lj) {
     Error err;
     CodeGen *g = lj->codegen;
 
-    lj->args.append("/ERRORLIMIT:0");
+    lj->args.append("-ERRORLIMIT:0");
 
-    lj->args.append("/NOLOGO");
+    lj->args.append("-NOLOGO");
 
     if (!g->strip_debug_symbols) {
-        lj->args.append("/DEBUG");
+        lj->args.append("-DEBUG");
     }
 
     if (g->out_type == OutTypeExe) {
         // TODO compile time stack upper bound detection
-        lj->args.append("/STACK:16777216");
+        lj->args.append("-STACK:16777216");
     }
 
     coff_append_machine_arg(g, &lj->args);
 
     bool is_library = g->out_type == OutTypeLib;
+    if (is_library && g->is_dynamic) {
+        lj->args.append("-DLL");
+    }
+
+    lj->args.append(buf_ptr(buf_sprintf("-OUT:%s", buf_ptr(&g->output_file_path))));
+
+    if (g->libc_link_lib != nullptr) {
+        assert(g->libc != nullptr);
+
+        lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", buf_ptr(&g->libc->crt_dir))));
+
+        if (target_abi_is_gnu(g->zig_target->abi)) {
+            lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", buf_ptr(&g->libc->sys_include_dir))));
+            lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", buf_ptr(&g->libc->include_dir))));
+        } else {
+            lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", buf_ptr(&g->libc->msvc_lib_dir))));
+            lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", buf_ptr(&g->libc->kernel32_lib_dir))));
+        }
+    }
+
+    for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
+        const char *lib_dir = g->lib_dirs.at(i);
+        lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", lib_dir)));
+    }
+
+    for (size_t i = 0; i < g->link_objects.length; i += 1) {
+        lj->args.append((const char *)buf_ptr(g->link_objects.at(i)));
+    }
+
     switch (g->subsystem) {
         case TargetSubsystemAuto:
             if (g->zig_target->os == OsUefi) {
                 add_uefi_link_args(lj);
             } else {
-                add_nt_link_args(lj, is_library);
+                add_win_link_args(lj, is_library);
             }
             break;
         case TargetSubsystemConsole:
-            lj->args.append("/SUBSYSTEM:console");
-            add_nt_link_args(lj, is_library);
+            lj->args.append("-SUBSYSTEM:console");
+            add_win_link_args(lj, is_library);
             break;
         case TargetSubsystemEfiApplication:
-            lj->args.append("/SUBSYSTEM:efi_application");
+            lj->args.append("-SUBSYSTEM:efi_application");
             add_uefi_link_args(lj);
             break;
         case TargetSubsystemEfiBootServiceDriver:
-            lj->args.append("/SUBSYSTEM:efi_boot_service_driver");
+            lj->args.append("-SUBSYSTEM:efi_boot_service_driver");
             add_uefi_link_args(lj);
             break;
         case TargetSubsystemEfiRom:
-            lj->args.append("/SUBSYSTEM:efi_rom");
+            lj->args.append("-SUBSYSTEM:efi_rom");
             add_uefi_link_args(lj);
             break;
         case TargetSubsystemEfiRuntimeDriver:
-            lj->args.append("/SUBSYSTEM:efi_runtime_driver");
+            lj->args.append("-SUBSYSTEM:efi_runtime_driver");
             add_uefi_link_args(lj);
             break;
         case TargetSubsystemNative:
-            lj->args.append("/SUBSYSTEM:native");
-            add_nt_link_args(lj, is_library);
+            lj->args.append("-SUBSYSTEM:native");
+            add_win_link_args(lj, is_library);
             break;
         case TargetSubsystemPosix:
-            lj->args.append("/SUBSYSTEM:posix");
-            add_nt_link_args(lj, is_library);
+            lj->args.append("-SUBSYSTEM:posix");
+            add_win_link_args(lj, is_library);
             break;
         case TargetSubsystemWindows:
-            lj->args.append("/SUBSYSTEM:windows");
-            add_nt_link_args(lj, is_library);
+            lj->args.append("-SUBSYSTEM:windows");
+            add_win_link_args(lj, is_library);
             break;
     }
 
-    lj->args.append(buf_ptr(buf_sprintf("-OUT:%s", buf_ptr(&g->output_file_path))));
-
-    if (g->libc_link_lib != nullptr) {
-        assert(g->libc != nullptr);
-
-        lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", buf_ptr(&g->libc->msvc_lib_dir))));
-        lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", buf_ptr(&g->libc->kernel32_lib_dir))));
-        lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", buf_ptr(&g->libc->crt_dir))));
-    }
-
-    if (is_library && g->is_dynamic) {
-        lj->args.append("-DLL");
-    }
-
-    for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
-        const char *lib_dir = g->lib_dirs.at(i);
-        lj->args.append(buf_ptr(buf_sprintf("-LIBPATH:%s", lib_dir)));
-    }
-
-    for (size_t i = 0; i < g->link_objects.length; i += 1) {
-        lj->args.append((const char *)buf_ptr(g->link_objects.at(i)));
-    }
-
     if (g->out_type == OutTypeExe || (g->out_type == OutTypeLib && g->is_dynamic)) {
         if (g->libc_link_lib == nullptr && !g->is_dummy_so) {
             Buf *builtin_a_path = build_a(g, "builtin");
@@ -1268,7 +1360,7 @@ static void construct_linker_job_coff(LinkJob *lj) {
         }
 
         // msvc compiler_rt is missing some stuff, so we still build it and rely on weak linkage
-        Buf *compiler_rt_o_path = build_compiler_rt(g);
+        Buf *compiler_rt_o_path = build_compiler_rt(g, OutTypeLib);
         lj->args.append(buf_ptr(compiler_rt_o_path));
     }
 
@@ -1280,11 +1372,10 @@ static void construct_linker_job_coff(LinkJob *lj) {
             continue;
         }
         if (link_lib->provided_explicitly) {
-            if (lj->codegen->zig_target->abi == ZigLLVM_GNU) {
-                Buf *arg = buf_sprintf("-l%s", buf_ptr(link_lib->name));
-                lj->args.append(buf_ptr(arg));
-            }
-            else {
+            if (target_abi_is_gnu(lj->codegen->zig_target->abi)) {
+                Buf *lib_name = buf_sprintf("lib%s.a", buf_ptr(link_lib->name));
+                lj->args.append(buf_ptr(lib_name));
+            } else {
                 lj->args.append(buf_ptr(link_lib->name));
             }
         } else {
@@ -1416,18 +1507,6 @@ static void get_darwin_platform(LinkJob *lj, DarwinPlatform *platform) {
     }
 }
 
-static bool darwin_version_lt(DarwinPlatform *platform, int major, int minor) {
-    if (platform->major < major) {
-        return true;
-    } else if (platform->major > major) {
-        return false;
-    }
-    if (platform->minor < minor) {
-        return true;
-    }
-    return false;
-}
-
 static void construct_linker_job_macho(LinkJob *lj) {
     CodeGen *g = lj->codegen;
 
@@ -1524,7 +1603,7 @@ static void construct_linker_job_macho(LinkJob *lj) {
 
     // compiler_rt on darwin is missing some stuff, so we still build it and rely on LinkOnce
     if (g->out_type == OutTypeExe || is_dyn_lib) {
-        Buf *compiler_rt_o_path = build_compiler_rt(g);
+        Buf *compiler_rt_o_path = build_compiler_rt(g, OutTypeLib);
         lj->args.append(buf_ptr(compiler_rt_o_path));
     }
 
@@ -1552,16 +1631,6 @@ static void construct_linker_job_macho(LinkJob *lj) {
         lj->args.append("dynamic_lookup");
     }
 
-    if (platform.kind == MacOS) {
-        if (darwin_version_lt(&platform, 10, 5)) {
-            lj->args.append("-lgcc_s.10.4");
-        } else if (darwin_version_lt(&platform, 10, 6)) {
-            lj->args.append("-lgcc_s.10.5");
-        }
-    } else {
-        zig_panic("TODO");
-    }
-
     for (size_t i = 0; i < g->darwin_frameworks.length; i += 1) {
         lj->args.append("-framework");
         lj->args.append(buf_ptr(g->darwin_frameworks.at(i)));
@@ -1585,6 +1654,11 @@ static void construct_linker_job(LinkJob *lj) {
     }
 }
 
+void zig_link_add_compiler_rt(CodeGen *g) {
+    Buf *compiler_rt_o_path = build_compiler_rt(g, OutTypeObj);
+    g->link_objects.append(compiler_rt_o_path);
+}
+
 void codegen_link(CodeGen *g) {
     codegen_add_time_event(g, "Build Dependencies");
 
@@ -1611,14 +1685,14 @@ void codegen_link(CodeGen *g) {
     if (g->out_type == OutTypeLib && !g->is_dynamic) {
         ZigList<const char *> file_names = {};
         for (size_t i = 0; i < g->link_objects.length; i += 1) {
-            file_names.append((const char *)buf_ptr(g->link_objects.at(i)));
+            file_names.append(buf_ptr(g->link_objects.at(i)));
         }
         ZigLLVM_OSType os_type = get_llvm_os_type(g->zig_target->os);
         codegen_add_time_event(g, "LLVM Link");
         if (g->verbose_link) {
             fprintf(stderr, "ar rcs %s", buf_ptr(&g->output_file_path));
-            for (size_t i = 0; i < g->link_objects.length; i += 1) {
-                fprintf(stderr, " %s", (const char *)buf_ptr(g->link_objects.at(i)));
+            for (size_t i = 0; i < file_names.length; i += 1) {
+                fprintf(stderr, " %s", file_names.at(i));
             }
             fprintf(stderr, "\n");
         }
diff --git a/src/list.hpp b/src/list.hpp
index b69a369f5a..f838e44a5b 100644
--- a/src/list.hpp
+++ b/src/list.hpp
@@ -10,8 +10,6 @@
 
 #include "util.hpp"
 
-#include <assert.h>
-
 template<typename T>
 struct ZigList {
     void deinit() {
diff --git a/src/main.cpp b/src/main.cpp
index bd3d574956..5659624cb7 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -14,6 +14,7 @@
 #include "os.hpp"
 #include "target.hpp"
 #include "libc_installation.hpp"
+#include "userland.h"
 
 #include <stdio.h>
 
@@ -40,6 +41,7 @@ static int print_full_usage(const char *arg0, FILE *file, int return_code) {
         "  libc [paths_file]            Display native libc paths file or validate one\n"
         "  run [source] [-- [args]]     create executable and run immediately\n"
         "  translate-c [source]         convert c code to zig code\n"
+        "  translate-c-2 [source]       experimental self-hosted translate-c\n"
         "  targets                      list available compilation targets\n"
         "  test [source]                create and run a test build\n"
         "  version                      print version number and exit\n"
@@ -52,11 +54,12 @@ static int print_full_usage(const char *arg0, FILE *file, int return_code) {
         "  --cache [auto|off|on]        build in cache, print output path to stdout\n"
         "  --color [auto|off|on]        enable or disable colored error messages\n"
         "  --disable-gen-h              do not generate a C header file (.h)\n"
-        "  --disable-pic                disable Position Independent Code\n"
-        "  --enable-pic                 enable Position Independent Code\n"
         "  --disable-valgrind           omit valgrind client requests in debug builds\n"
         "  --enable-valgrind            include valgrind client requests release builds\n"
+        "  --disable-stack-probing      workaround for macosx\n"
         "  --emit [asm|bin|llvm-ir]     emit a specific file format as compilation output\n"
+        "  -fPIC                        enable Position Independent Code\n"
+        "  -fno-PIC                     disable Position Independent Code\n"
         "  -ftime-report                print timing diagnostics\n"
         "  --libc [file]                Provide a file which specifies libc paths\n"
         "  --name [name]                override output name\n"
@@ -84,6 +87,7 @@ static int print_full_usage(const char *arg0, FILE *file, int return_code) {
         "  --override-std-dir [arg]     use an alternate Zig standard library\n"
         "\n"
         "Link Options:\n"
+        "  --bundle-compiler-rt [path]  for static libraries, include compiler-rt symbols\n"
         "  --dynamic-linker [path]      set the path to ld.so\n"
         "  --each-lib-rpath             add rpath for each used dynamic library\n"
         "  --library [lib]              link against lib\n"
@@ -131,19 +135,6 @@ static int print_libc_usage(const char *arg0, FILE *file, int return_code) {
     return return_code;
 }
 
-static const char *ZIG_ZEN = "\n"
-" * Communicate intent precisely.\n"
-" * Edge cases matter.\n"
-" * Favor reading code over writing code.\n"
-" * Only one obvious way to do things.\n"
-" * Runtime crashes are better than bugs.\n"
-" * Compile errors are better than runtime crashes.\n"
-" * Incremental improvements.\n"
-" * Avoid local maximums.\n"
-" * Reduce the amount one must remember.\n"
-" * Minimize energy spent on coding style.\n"
-" * Together we serve end users.\n";
-
 static bool arch_available_in_llvm(ZigLLVM_ArchType arch) {
     LLVMTargetRef target_ref;
     char *err_msg = nullptr;
@@ -211,6 +202,7 @@ enum Cmd {
     CmdTargets,
     CmdTest,
     CmdTranslateC,
+    CmdTranslateCUserland,
     CmdVersion,
     CmdZen,
     CmdLibC,
@@ -324,7 +316,7 @@ int main(int argc, char **argv) {
                 return print_error_usage(arg0);
             }
             Buf *cmd_template_path = buf_alloc();
-            os_path_join(get_zig_special_dir(), buf_create_from_str(init_cmd), cmd_template_path);
+            os_path_join(get_zig_special_dir(get_zig_lib_dir()), buf_create_from_str(init_cmd), cmd_template_path);
             Buf *build_zig_path = buf_alloc();
             os_path_join(cmd_template_path, buf_create_from_str("build.zig"), build_zig_path);
             Buf *src_dir_path = buf_alloc();
@@ -341,7 +333,7 @@ int main(int argc, char **argv) {
             os_path_split(cwd, nullptr, cwd_basename);
 
             Buf *build_zig_contents = buf_alloc();
-            if ((err = os_fetch_file_path(build_zig_path, build_zig_contents, false))) {
+            if ((err = os_fetch_file_path(build_zig_path, build_zig_contents))) {
                 fprintf(stderr, "Unable to read %s: %s\n", buf_ptr(build_zig_path), err_str(err));
                 return EXIT_FAILURE;
             }
@@ -356,7 +348,7 @@ int main(int argc, char **argv) {
             }
 
             Buf *main_zig_contents = buf_alloc();
-            if ((err = os_fetch_file_path(main_zig_path, main_zig_contents, false))) {
+            if ((err = os_fetch_file_path(main_zig_path, main_zig_contents))) {
                 fprintf(stderr, "Unable to read %s: %s\n", buf_ptr(main_zig_path), err_str(err));
                 return EXIT_FAILURE;
             }
@@ -450,9 +442,12 @@ int main(int argc, char **argv) {
     int runtime_args_start = -1;
     bool system_linker_hack = false;
     TargetSubsystem subsystem = TargetSubsystemAuto;
-    bool is_single_threaded = false;
+    bool want_single_threaded = false;
     bool disable_gen_h = false;
+    bool bundle_compiler_rt = false;
+    bool disable_stack_probing = false;
     Buf *override_std_dir = nullptr;
+    Buf *override_lib_dir = nullptr;
     Buf *main_pkg_path = nullptr;
     ValgrindSupport valgrind_support = ValgrindSupportAuto;
     WantPIC want_pic = WantPICAuto;
@@ -486,13 +481,27 @@ int main(int argc, char **argv) {
             } else if (i + 1 < argc && strcmp(argv[i], "--cache-dir") == 0) {
                 cache_dir = argv[i + 1];
                 i += 1;
+            } else if (i + 1 < argc && strcmp(argv[i], "--override-std-dir") == 0) {
+                override_std_dir = buf_create_from_str(argv[i + 1]);
+                i += 1;
+
+                args.append("--override-std-dir");
+                args.append(buf_ptr(override_std_dir));
+            } else if (i + 1 < argc && strcmp(argv[i], "--override-lib-dir") == 0) {
+                override_lib_dir = buf_create_from_str(argv[i + 1]);
+                i += 1;
+
+                args.append("--override-lib-dir");
+                args.append(buf_ptr(override_lib_dir));
             } else {
                 args.append(argv[i]);
             }
         }
 
+        Buf *zig_lib_dir = (override_lib_dir == nullptr) ? get_zig_lib_dir() : override_lib_dir;
+
         Buf *build_runner_path = buf_alloc();
-        os_path_join(get_zig_special_dir(), buf_create_from_str("build_runner.zig"), build_runner_path);
+        os_path_join(get_zig_special_dir(zig_lib_dir), buf_create_from_str("build_runner.zig"), build_runner_path);
 
         ZigTarget target;
         get_native_target(&target);
@@ -512,7 +521,7 @@ int main(int argc, char **argv) {
         }
 
         CodeGen *g = codegen_create(main_pkg_path, build_runner_path, &target, OutTypeExe,
-                BuildModeDebug, get_zig_lib_dir(), override_std_dir, nullptr, &full_cache_dir);
+                BuildModeDebug, override_lib_dir, override_std_dir, nullptr, &full_cache_dir);
         g->valgrind_support = valgrind_support;
         g->enable_time_report = timing_info;
         codegen_set_out_name(g, buf_create_from_str("build"));
@@ -532,23 +541,25 @@ int main(int argc, char **argv) {
                         "Usage: %s build [options]\n"
                         "\n"
                         "General Options:\n"
-                        "  --help                 Print this help and exit\n"
-                        "  --verbose              Print commands before executing them\n"
-                        "  --prefix [path]        Override default install prefix\n"
-                        "  --search-prefix [path] Add a path to look for binaries, libraries, headers\n"
+                        "  --help                   Print this help and exit\n"
+                        "  --verbose                Print commands before executing them\n"
+                        "  --prefix [path]          Override default install prefix\n"
+                        "  --search-prefix [path]   Add a path to look for binaries, libraries, headers\n"
                         "\n"
                         "Project-specific options become available when the build file is found.\n"
                         "\n"
                         "Advanced Options:\n"
-                        "  --build-file [file]    Override path to build.zig\n"
-                        "  --cache-dir [path]     Override path to cache directory\n"
-                        "  --verbose-tokenize     Enable compiler debug output for tokenization\n"
-                        "  --verbose-ast          Enable compiler debug output for parsing into an AST\n"
-                        "  --verbose-link         Enable compiler debug output for linking\n"
-                        "  --verbose-ir           Enable compiler debug output for Zig IR\n"
-                        "  --verbose-llvm-ir      Enable compiler debug output for LLVM IR\n"
-                        "  --verbose-cimport      Enable compiler debug output for C imports\n"
-                        "  --verbose-cc           Enable compiler debug output for C compilation\n"
+                        "  --build-file [file]      Override path to build.zig\n"
+                        "  --cache-dir [path]       Override path to cache directory\n"
+                        "  --override-std-dir [arg] Override path to Zig standard library\n"
+                        "  --override-lib-dir [arg] Override path to Zig lib library\n"
+                        "  --verbose-tokenize       Enable compiler debug output for tokenization\n"
+                        "  --verbose-ast            Enable compiler debug output for parsing into an AST\n"
+                        "  --verbose-link           Enable compiler debug output for linking\n"
+                        "  --verbose-ir             Enable compiler debug output for Zig IR\n"
+                        "  --verbose-llvm-ir        Enable compiler debug output for LLVM IR\n"
+                        "  --verbose-cimport        Enable compiler debug output for C imports\n"
+                        "  --verbose-cc             Enable compiler debug output for C compilation\n"
                         "\n"
                 , zig_exe_path);
                 return EXIT_SUCCESS;
@@ -581,36 +592,7 @@ int main(int argc, char **argv) {
         }
         return (term.how == TerminationIdClean) ? term.code : -1;
     } else if (argc >= 2 && strcmp(argv[1], "fmt") == 0) {
-        init_all_targets();
-        ZigTarget target;
-        get_native_target(&target);
-        Buf *fmt_runner_path = buf_alloc();
-        os_path_join(get_zig_special_dir(), buf_create_from_str("fmt_runner.zig"), fmt_runner_path);
-        Buf *cache_dir_buf = buf_create_from_str(cache_dir ? cache_dir : default_zig_cache_name);
-        CodeGen *g = codegen_create(main_pkg_path, fmt_runner_path, &target, OutTypeExe,
-                BuildModeDebug, get_zig_lib_dir(), nullptr, nullptr, cache_dir_buf);
-        g->valgrind_support = valgrind_support;
-        g->is_single_threaded = true;
-        codegen_set_out_name(g, buf_create_from_str("fmt"));
-        g->enable_cache = true;
-
-        codegen_build_and_link(g);
-
-        // TODO standardize os.cpp so that the args are supposed to have the exe
-        ZigList<const char*> args_with_exe = {0};
-        ZigList<const char*> args_without_exe = {0};
-        const char *exec_path = buf_ptr(&g->output_file_path);
-        args_with_exe.append(exec_path);
-        for (int i = 2; i < argc; i += 1) {
-            args_with_exe.append(argv[i]);
-            args_without_exe.append(argv[i]);
-        }
-        args_with_exe.append(nullptr);
-        os_execv(exec_path, args_with_exe.items);
-
-        Termination term;
-        os_spawn_process(exec_path, args_without_exe, &term);
-        return term.code;
+        return stage2_fmt(argc, argv);
     }
 
     for (int i = 1; i < argc; i += 1) {
@@ -664,16 +646,20 @@ int main(int argc, char **argv) {
                 valgrind_support = ValgrindSupportEnabled;
             } else if (strcmp(arg, "--disable-valgrind") == 0) {
                 valgrind_support = ValgrindSupportDisabled;
-            } else if (strcmp(arg, "--enable-pic") == 0) {
+            } else if (strcmp(arg, "-fPIC") == 0) {
                 want_pic = WantPICEnabled;
-            } else if (strcmp(arg, "--disable-pic") == 0) {
+            } else if (strcmp(arg, "-fno-PIC") == 0) {
                 want_pic = WantPICDisabled;
             } else if (strcmp(arg, "--system-linker-hack") == 0) {
                 system_linker_hack = true;
             } else if (strcmp(arg, "--single-threaded") == 0) {
-                is_single_threaded = true;
+                want_single_threaded = true;
             } else if (strcmp(arg, "--disable-gen-h") == 0) {
                 disable_gen_h = true;
+            } else if (strcmp(arg, "--bundle-compiler-rt") == 0) {
+                bundle_compiler_rt = true;
+            } else if (strcmp(arg, "--disable-stack-probing") == 0) {
+                disable_stack_probing = true;
             } else if (strcmp(arg, "--test-cmd-bin") == 0) {
                 test_exec_args.append(nullptr);
             } else if (arg[1] == 'L' && arg[2] != 0) {
@@ -757,6 +743,8 @@ int main(int argc, char **argv) {
                     llvm_argv.append(argv[i]);
                 } else if (strcmp(arg, "--override-std-dir") == 0) {
                     override_std_dir = buf_create_from_str(argv[i]);
+                } else if (strcmp(arg, "--override-lib-dir") == 0) {
+                    override_lib_dir = buf_create_from_str(argv[i]);
                 } else if (strcmp(arg, "--main-pkg-path") == 0) {
                     main_pkg_path = buf_create_from_str(argv[i]);
                 } else if (strcmp(arg, "--library-path") == 0 || strcmp(arg, "-L") == 0) {
@@ -775,7 +763,11 @@ int main(int argc, char **argv) {
                         if (argv[i][0] == '-') {
                             c_file->args.append(argv[i]);
                             i += 1;
-                            continue;
+                            if (i < argc) {
+                                continue;
+                            }
+
+                            break;
                         } else {
                             c_file->source_path = argv[i];
                             c_source_files.append(c_file);
@@ -867,6 +859,8 @@ int main(int argc, char **argv) {
                 cmd = CmdLibC;
             } else if (strcmp(arg, "translate-c") == 0) {
                 cmd = CmdTranslateC;
+            } else if (strcmp(arg, "translate-c-2") == 0) {
+                cmd = CmdTranslateCUserland;
             } else if (strcmp(arg, "test") == 0) {
                 cmd = CmdTest;
                 out_type = OutTypeExe;
@@ -883,6 +877,7 @@ int main(int argc, char **argv) {
                 case CmdBuild:
                 case CmdRun:
                 case CmdTranslateC:
+                case CmdTranslateCUserland:
                 case CmdTest:
                 case CmdLibC:
                     if (!in_file) {
@@ -959,10 +954,10 @@ int main(int argc, char **argv) {
     }
     case CmdBuiltin: {
         CodeGen *g = codegen_create(main_pkg_path, nullptr, &target,
-                out_type, build_mode, get_zig_lib_dir(), override_std_dir, nullptr, nullptr);
+                out_type, build_mode, override_lib_dir, override_std_dir, nullptr, nullptr);
         g->valgrind_support = valgrind_support;
         g->want_pic = want_pic;
-        g->is_single_threaded = is_single_threaded;
+        g->want_single_threaded = want_single_threaded;
         Buf *builtin_source = codegen_generate_builtin_source(g);
         if (fwrite(buf_ptr(builtin_source), 1, buf_len(builtin_source), stdout) != buf_len(builtin_source)) {
             fprintf(stderr, "unable to write to stdout: %s\n", strerror(ferror(stdout)));
@@ -973,6 +968,7 @@ int main(int argc, char **argv) {
     case CmdRun:
     case CmdBuild:
     case CmdTranslateC:
+    case CmdTranslateCUserland:
     case CmdTest:
         {
             if (cmd == CmdBuild && !in_file && objects.length == 0 && asm_files.length == 0 &&
@@ -985,14 +981,16 @@ int main(int argc, char **argv) {
                     " * --assembly argument\n"
                     " * --c-source argument\n");
                 return print_error_usage(arg0);
-            } else if ((cmd == CmdTranslateC || cmd == CmdTest || cmd == CmdRun) && !in_file) {
+            } else if ((cmd == CmdTranslateC || cmd == CmdTranslateCUserland ||
+                        cmd == CmdTest || cmd == CmdRun) && !in_file)
+            {
                 fprintf(stderr, "Expected source file argument.\n");
                 return print_error_usage(arg0);
             }
 
             assert(cmd != CmdBuild || out_type != OutTypeUnknown);
 
-            bool need_name = (cmd == CmdBuild || cmd == CmdTranslateC);
+            bool need_name = (cmd == CmdBuild || cmd == CmdTranslateC || cmd == CmdTranslateCUserland);
 
             if (cmd == CmdRun) {
                 out_name = "run";
@@ -1026,7 +1024,8 @@ int main(int argc, char **argv) {
                 return print_error_usage(arg0);
             }
 
-            Buf *zig_root_source_file = (cmd == CmdTranslateC) ? nullptr : in_file_buf;
+            Buf *zig_root_source_file = (cmd == CmdTranslateC || cmd == CmdTranslateCUserland) ?
+                nullptr : in_file_buf;
 
             if (cmd == CmdRun && buf_out_name == nullptr) {
                 buf_out_name = buf_create_from_str("run");
@@ -1050,7 +1049,7 @@ int main(int argc, char **argv) {
                 cache_dir_buf = buf_create_from_str(cache_dir);
             }
             CodeGen *g = codegen_create(main_pkg_path, zig_root_source_file, &target, out_type, build_mode,
-                    get_zig_lib_dir(), override_std_dir, libc, cache_dir_buf);
+                    override_lib_dir, override_std_dir, libc, cache_dir_buf);
             if (llvm_argv.length >= 2) codegen_set_llvm_argv(g, llvm_argv.items + 1, llvm_argv.length - 2);
             g->valgrind_support = valgrind_support;
             g->want_pic = want_pic;
@@ -1060,7 +1059,7 @@ int main(int argc, char **argv) {
             codegen_set_out_name(g, buf_out_name);
             codegen_set_lib_version(g, ver_major, ver_minor, ver_patch);
             codegen_set_is_test(g, cmd == CmdTest);
-            g->is_single_threaded = is_single_threaded;
+            g->want_single_threaded = want_single_threaded;
             codegen_set_linker_script(g, linker_script);
             if (each_lib_rpath)
                 codegen_set_each_lib_rpath(g, each_lib_rpath);
@@ -1079,6 +1078,8 @@ int main(int argc, char **argv) {
             g->verbose_cc = verbose_cc;
             g->output_dir = output_dir;
             g->disable_gen_h = disable_gen_h;
+            g->bundle_compiler_rt = bundle_compiler_rt;
+            g->disable_stack_probing = disable_stack_probing;
             codegen_set_errmsg_color(g, color);
             g->system_linker_hack = system_linker_hack;
 
@@ -1144,14 +1145,15 @@ int main(int argc, char **argv) {
                     codegen_print_timing_report(g, stdout);
 
                 if (cmd == CmdRun) {
+                    const char *exec_path = buf_ptr(&g->output_file_path);
                     ZigList<const char*> args = {0};
+
+                    args.append(exec_path);
                     if (runtime_args_start != -1) {
                         for (int i = runtime_args_start; i < argc; ++i) {
                             args.append(argv[i]);
                         }
                     }
-
-                    const char *exec_path = buf_ptr(&g->output_file_path);
                     args.append(nullptr);
 
                     os_execv(exec_path, args.items);
@@ -1169,9 +1171,8 @@ int main(int argc, char **argv) {
                 } else {
                     zig_unreachable();
                 }
-            } else if (cmd == CmdTranslateC) {
-                AstNode *root_node = codegen_translate_c(g, in_file_buf);
-                ast_render(g, stdout, root_node, 4);
+            } else if (cmd == CmdTranslateC || cmd == CmdTranslateCUserland) {
+                codegen_translate_c(g, in_file_buf, stdout, cmd == CmdTranslateCUserland);
                 if (timing_info)
                     codegen_print_timing_report(g, stderr);
                 return EXIT_SUCCESS;
@@ -1228,9 +1229,13 @@ int main(int argc, char **argv) {
     case CmdVersion:
         printf("%s\n", ZIG_VERSION_STRING);
         return EXIT_SUCCESS;
-    case CmdZen:
-        printf("%s\n", ZIG_ZEN);
+    case CmdZen: {
+        const char *ptr;
+        size_t len;
+        stage2_zen(&ptr, &len);
+        fwrite(ptr, len, 1, stdout);
         return EXIT_SUCCESS;
+    }
     case CmdTargets:
         return print_target_list(stdout);
     case CmdNone:
diff --git a/src/os.cpp b/src/os.cpp
index 470d222307..83c67d5818 100644
--- a/src/os.cpp
+++ b/src/os.cpp
@@ -751,39 +751,15 @@ Buf os_path_resolve(Buf **paths_ptr, size_t paths_len) {
 #endif
 }
 
-Error os_fetch_file(FILE *f, Buf *out_buf, bool skip_shebang) {
+Error os_fetch_file(FILE *f, Buf *out_buf) {
     static const ssize_t buf_size = 0x2000;
     buf_resize(out_buf, buf_size);
     ssize_t actual_buf_len = 0;
 
-    bool first_read = true;
-
     for (;;) {
         size_t amt_read = fread(buf_ptr(out_buf) + actual_buf_len, 1, buf_size, f);
         actual_buf_len += amt_read;
 
-        if (skip_shebang && first_read && buf_starts_with_str(out_buf, "#!")) {
-            size_t i = 0;
-            while (true) {
-                if (i > buf_len(out_buf)) {
-                    zig_panic("shebang line exceeded %zd characters", buf_size);
-                }
-
-                size_t current_pos = i;
-                i += 1;
-
-                if (out_buf->list.at(current_pos) == '\n') {
-                    break;
-                }
-            }
-
-            ZigList<char> *list = &out_buf->list;
-            memmove(list->items, list->items + i, list->length - i);
-            list->length -= i;
-
-            actual_buf_len -= i;
-        }
-
         if (amt_read != buf_size) {
             if (feof(f)) {
                 buf_resize(out_buf, actual_buf_len);
@@ -794,7 +770,6 @@ Error os_fetch_file(FILE *f, Buf *out_buf, bool skip_shebang) {
         }
 
         buf_resize(out_buf, actual_buf_len + buf_size);
-        first_read = false;
     }
     zig_unreachable();
 }
@@ -864,8 +839,8 @@ static Error os_exec_process_posix(const char *exe, ZigList<const char *> &args,
 
         FILE *stdout_f = fdopen(stdout_pipe[0], "rb");
         FILE *stderr_f = fdopen(stderr_pipe[0], "rb");
-        Error err1 = os_fetch_file(stdout_f, out_stdout, false);
-        Error err2 = os_fetch_file(stderr_f, out_stderr, false);
+        Error err1 = os_fetch_file(stdout_f, out_stdout);
+        Error err2 = os_fetch_file(stderr_f, out_stderr);
 
         fclose(stdout_f);
         fclose(stderr_f);
@@ -1097,7 +1072,7 @@ Error os_copy_file(Buf *src_path, Buf *dest_path) {
     }
 }
 
-Error os_fetch_file_path(Buf *full_path, Buf *out_contents, bool skip_shebang) {
+Error os_fetch_file_path(Buf *full_path, Buf *out_contents) {
     FILE *f = fopen(buf_ptr(full_path), "rb");
     if (!f) {
         switch (errno) {
@@ -1116,7 +1091,7 @@ Error os_fetch_file_path(Buf *full_path, Buf *out_contents, bool skip_shebang) {
                 return ErrorFileSystem;
         }
     }
-    Error result = os_fetch_file(f, out_contents, skip_shebang);
+    Error result = os_fetch_file(f, out_contents);
     fclose(f);
     return result;
 }
@@ -1772,8 +1747,14 @@ Error os_get_app_data_dir(Buf *out_path, const char *appname) {
         // TODO use /etc/passwd
         return ErrorFileNotFound;
     }
-    buf_resize(out_path, 0);
-    buf_appendf(out_path, "%s/.local/share/%s", home_dir, appname);
+    if (home_dir[0] == 0) {
+        return ErrorFileNotFound;
+    }
+    buf_init_from_str(out_path, home_dir);
+    if (buf_ptr(out_path)[buf_len(out_path) - 1] != '/') {
+        buf_append_char(out_path, '/');
+    }
+    buf_appendf(out_path, ".local/share/%s", appname);
     return ErrorNone;
 #endif
 }
@@ -2081,11 +2062,13 @@ Error os_file_overwrite(OsFile file, Buf *contents) {
 #endif
 }
 
-void os_file_close(OsFile file) {
+void os_file_close(OsFile *file) {
 #if defined(ZIG_OS_WINDOWS)
-    CloseHandle(file);
+    CloseHandle(*file);
+    *file = NULL;
 #else
-    close(file);
+    close(*file);
+    *file = -1;
 #endif
 }
 
diff --git a/src/os.hpp b/src/os.hpp
index 5064a6444c..058bb2020c 100644
--- a/src/os.hpp
+++ b/src/os.hpp
@@ -121,13 +121,13 @@ Error ATTRIBUTE_MUST_USE os_file_open_lock_rw(Buf *full_path, OsFile *out_file);
 Error ATTRIBUTE_MUST_USE os_file_read(OsFile file, void *ptr, size_t *len);
 Error ATTRIBUTE_MUST_USE os_file_read_all(OsFile file, Buf *contents);
 Error ATTRIBUTE_MUST_USE os_file_overwrite(OsFile file, Buf *contents);
-void os_file_close(OsFile file);
+void os_file_close(OsFile *file);
 
 Error ATTRIBUTE_MUST_USE os_write_file(Buf *full_path, Buf *contents);
 Error ATTRIBUTE_MUST_USE os_copy_file(Buf *src_path, Buf *dest_path);
 
-Error ATTRIBUTE_MUST_USE os_fetch_file(FILE *file, Buf *out_contents, bool skip_shebang);
-Error ATTRIBUTE_MUST_USE os_fetch_file_path(Buf *full_path, Buf *out_contents, bool skip_shebang);
+Error ATTRIBUTE_MUST_USE os_fetch_file(FILE *file, Buf *out_contents);
+Error ATTRIBUTE_MUST_USE os_fetch_file_path(Buf *full_path, Buf *out_contents);
 
 Error ATTRIBUTE_MUST_USE os_get_cwd(Buf *out_cwd);
 
diff --git a/src/parser.cpp b/src/parser.cpp
index 9172e21b92..583accfd72 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -577,7 +577,7 @@ static AstNode *ast_parse_top_level_comptime(ParseContext *pc) {
 
 // TopLevelDecl
 //     <- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / KEYWORD_inline)? FnProto (SEMICOLON / Block)
-//      / (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? VarDecl
+//      / (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? KEYWORD_threadlocal? VarDecl
 //      / KEYWORD_use Expr SEMICOLON
 static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
     Token *first = eat_token_if(pc, TokenIdKeywordExport);
@@ -591,17 +591,22 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
             lib_name = eat_token_if(pc, TokenIdStringLiteral);
 
         if (first->id != TokenIdKeywordInline) {
+            Token *thread_local_kw = eat_token_if(pc, TokenIdKeywordThreadLocal);
             AstNode *var_decl = ast_parse_var_decl(pc);
             if (var_decl != nullptr) {
                 assert(var_decl->type == NodeTypeVariableDeclaration);
                 var_decl->line = first->start_line;
                 var_decl->column = first->start_column;
+                var_decl->data.variable_declaration.threadlocal_tok = thread_local_kw;
                 var_decl->data.variable_declaration.visib_mod = visib_mod;
                 var_decl->data.variable_declaration.is_extern = first->id == TokenIdKeywordExtern;
                 var_decl->data.variable_declaration.is_export = first->id == TokenIdKeywordExport;
                 var_decl->data.variable_declaration.lib_name = token_buf(lib_name);
                 return var_decl;
             }
+
+            if (thread_local_kw != nullptr)
+                put_back_token(pc);
         }
 
         AstNode *fn_proto = ast_parse_fn_proto(pc);
@@ -632,13 +637,18 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod) {
         ast_invalid_token_error(pc, peek_token(pc));
     }
 
+    Token *thread_local_kw = eat_token_if(pc, TokenIdKeywordThreadLocal);
     AstNode *var_decl = ast_parse_var_decl(pc);
     if (var_decl != nullptr) {
         assert(var_decl->type == NodeTypeVariableDeclaration);
         var_decl->data.variable_declaration.visib_mod = visib_mod;
+        var_decl->data.variable_declaration.threadlocal_tok = thread_local_kw;
         return var_decl;
     }
 
+    if (thread_local_kw != nullptr)
+        put_back_token(pc);
+
     AstNode *fn_proto = ast_parse_fn_proto(pc);
     if (fn_proto != nullptr) {
         AstNode *body = ast_parse_block(pc);
@@ -741,17 +751,12 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc) {
 
 // VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON
 static AstNode *ast_parse_var_decl(ParseContext *pc) {
-    Token *thread_local_kw = eat_token_if(pc, TokenIdKeywordThreadLocal);
     Token *mut_kw = eat_token_if(pc, TokenIdKeywordConst);
     if (mut_kw == nullptr)
         mut_kw = eat_token_if(pc, TokenIdKeywordVar);
-    if (mut_kw == nullptr) {
-        if (thread_local_kw == nullptr) {
-            return nullptr;
-        } else {
-            ast_invalid_token_error(pc, peek_token(pc));
-        }
-    }
+    if (mut_kw == nullptr)
+        return nullptr;
+
     Token *identifier = expect_token(pc, TokenIdSymbol);
     AstNode *type_expr = nullptr;
     if (eat_token_if(pc, TokenIdColon) != nullptr)
@@ -766,7 +771,6 @@ static AstNode *ast_parse_var_decl(ParseContext *pc) {
     expect_token(pc, TokenIdSemicolon);
 
     AstNode *res = ast_create_node(pc, NodeTypeVariableDeclaration, mut_kw);
-    res->data.variable_declaration.threadlocal_tok = thread_local_kw;
     res->data.variable_declaration.is_const = mut_kw->id == TokenIdKeywordConst;
     res->data.variable_declaration.symbol = token_buf(identifier);
     res->data.variable_declaration.type = type_expr;
@@ -952,17 +956,10 @@ static AstNode *ast_parse_labeled_statement(ParseContext *pc) {
 
 // LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
 static AstNode *ast_parse_loop_statement(ParseContext *pc) {
-    Token *label = ast_parse_block_label(pc);
-    Token *first = label;
-
     Token *inline_token = eat_token_if(pc, TokenIdKeywordInline);
-    if (first == nullptr)
-        first = inline_token;
-
     AstNode *for_statement = ast_parse_for_statement(pc);
     if (for_statement != nullptr) {
         assert(for_statement->type == NodeTypeForExpr);
-        for_statement->data.for_expr.name = token_buf(label);
         for_statement->data.for_expr.is_inline = inline_token != nullptr;
         return for_statement;
     }
@@ -970,12 +967,11 @@ static AstNode *ast_parse_loop_statement(ParseContext *pc) {
     AstNode *while_statement = ast_parse_while_statement(pc);
     if (while_statement != nullptr) {
         assert(while_statement->type == NodeTypeWhileExpr);
-        while_statement->data.while_expr.name = token_buf(label);
         while_statement->data.while_expr.is_inline = inline_token != nullptr;
         return while_statement;
     }
 
-    if (first != nullptr)
+    if (inline_token != nullptr)
         ast_invalid_token_error(pc, peek_token(pc));
     return nullptr;
 }
@@ -1117,7 +1113,7 @@ static AstNode *ast_parse_bool_and_expr(ParseContext *pc) {
 
 // CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
 static AstNode *ast_parse_compare_expr(ParseContext *pc) {
-    return ast_parse_bin_op_expr(pc, BinOpChainInf, ast_parse_compare_op, ast_parse_bitwise_expr);
+    return ast_parse_bin_op_expr(pc, BinOpChainOnce, ast_parse_compare_op, ast_parse_bitwise_expr);
 }
 
 // BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
@@ -1162,10 +1158,6 @@ static AstNode *ast_parse_prefix_expr(ParseContext *pc) {
 //      / Block
 //      / CurlySuffixExpr
 static AstNode *ast_parse_primary_expr(ParseContext *pc) {
-    AstNode *enum_lit = ast_parse_enum_lit(pc);
-    if (enum_lit != nullptr)
-        return enum_lit;
-
     AstNode *asm_expr = ast_parse_asm_expr(pc);
     if (asm_expr != nullptr)
         return asm_expr;
@@ -1246,11 +1238,8 @@ static AstNode *ast_parse_primary_expr(ParseContext *pc) {
     }
 
     AstNode *block = ast_parse_block(pc);
-    if (block != nullptr) {
-        assert(block->type == NodeTypeBlock);
-        block->data.block.name = token_buf(label);
+    if (block != nullptr)
         return block;
-    }
 
     AstNode *curly_suffix = ast_parse_curly_suffix_expr(pc);
     if (curly_suffix != nullptr)
@@ -1503,6 +1492,7 @@ static AstNode *ast_parse_suffix_expr(ParseContext *pc) {
 //     <- BUILTINIDENTIFIER FnCallArguments
 //      / CHAR_LITERAL
 //      / ContainerDecl
+//     / DOT IDENTIFIER
 //      / ErrorSetDecl
 //      / FLOAT
 //      / FnProto
@@ -1563,6 +1553,10 @@ static AstNode *ast_parse_primary_type_expr(ParseContext *pc) {
     if (container_decl != nullptr)
         return container_decl;
 
+    AstNode *enum_lit = ast_parse_enum_lit(pc);
+    if (enum_lit != nullptr)
+        return enum_lit;
+
     AstNode *error_set_decl = ast_parse_error_set_decl(pc);
     if (error_set_decl != nullptr)
         return error_set_decl;
@@ -1672,32 +1666,26 @@ static AstNode *ast_parse_primary_type_expr(ParseContext *pc) {
 
 // ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
 static AstNode *ast_parse_container_decl(ParseContext *pc) {
-    Token *extern_token = eat_token_if(pc, TokenIdKeywordExtern);
-    if (extern_token != nullptr) {
-        AstNode *res = ast_parse_container_decl_auto(pc);
-        if (res == nullptr) {
-            put_back_token(pc);
-            return nullptr;
-        }
+    Token *layout_token = eat_token_if(pc, TokenIdKeywordExtern);
+    if (layout_token == nullptr)
+        layout_token = eat_token_if(pc, TokenIdKeywordPacked);
 
-        assert(res->type == NodeTypeContainerDecl);
-        res->line = extern_token->start_line;
-        res->column = extern_token->start_column;
-        res->data.container_decl.layout = ContainerLayoutExtern;
-        return res;
+    AstNode *res = ast_parse_container_decl_auto(pc);
+    if (res == nullptr) {
+        if (layout_token != nullptr)
+            put_back_token(pc);
+        return nullptr;
     }
 
-    Token *packed_token = eat_token_if(pc, TokenIdKeywordPacked);
-    if (packed_token != nullptr) {
-        AstNode *res = ast_expect(pc, ast_parse_container_decl_auto);
-        assert(res->type == NodeTypeContainerDecl);
-        res->line = packed_token->start_line;
-        res->column = packed_token->start_column;
-        res->data.container_decl.layout = ContainerLayoutPacked;
-        return res;
+    assert(res->type == NodeTypeContainerDecl);
+    if (layout_token != nullptr) {
+        res->line = layout_token->start_line;
+        res->column = layout_token->start_column;
+        res->data.container_decl.layout = layout_token->id == TokenIdKeywordExtern
+            ? ContainerLayoutExtern
+            : ContainerLayoutPacked;
     }
-
-    return ast_parse_container_decl_auto(pc);
+    return res;
 }
 
 // ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
@@ -1971,7 +1959,14 @@ static AstNode *ast_parse_field_init(ParseContext *pc) {
         return nullptr;
 
     Token *name = expect_token(pc, TokenIdSymbol);
-    expect_token(pc, TokenIdEq);
+    if (eat_token_if(pc, TokenIdEq) == nullptr) {
+        // Because ".Name" can also be intepreted as an enum literal, we should put back
+        // those two tokens again so that the parser can try to parse them as the enum
+        // literal later.
+        put_back_token(pc);
+        put_back_token(pc);
+        return nullptr;
+    }
     AstNode *expr = ast_expect(pc, ast_parse_expr);
 
     AstNode *res = ast_create_node(pc, NodeTypeStructValueField, first);
@@ -2750,12 +2745,19 @@ static AstNode *ast_parse_container_decl_auto(ParseContext *pc) {
 }
 
 // ContainerDeclType
-//     <- (KEYWORD_struct / KEYWORD_enum) (LPAREN Expr RPAREN)?
+//     <- KEYWORD_struct
+//      / KEYWORD_enum (LPAREN Expr RPAREN)?
 //      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
 static AstNode *ast_parse_container_decl_type(ParseContext *pc) {
     Token *first = eat_token_if(pc, TokenIdKeywordStruct);
-    if (first == nullptr)
-        first = eat_token_if(pc, TokenIdKeywordEnum);
+    if (first != nullptr) {
+        AstNode *res = ast_create_node(pc, NodeTypeContainerDecl, first);
+        res->data.container_decl.init_arg_expr = nullptr;
+        res->data.container_decl.kind = ContainerKindStruct;
+        return res;
+    }
+
+    first = eat_token_if(pc, TokenIdKeywordEnum);
     if (first != nullptr) {
         AstNode *init_arg_expr = nullptr;
         if (eat_token_if(pc, TokenIdLParen) != nullptr) {
@@ -2764,9 +2766,7 @@ static AstNode *ast_parse_container_decl_type(ParseContext *pc) {
         }
         AstNode *res = ast_create_node(pc, NodeTypeContainerDecl, first);
         res->data.container_decl.init_arg_expr = init_arg_expr;
-        res->data.container_decl.kind = first->id == TokenIdKeywordStruct
-            ? ContainerKindStruct
-            : ContainerKindEnum;
+        res->data.container_decl.kind = ContainerKindEnum;
         return res;
     }
 
diff --git a/src/target.cpp b/src/target.cpp
index dda8188765..1954fd7e2e 100644
--- a/src/target.cpp
+++ b/src/target.cpp
@@ -894,10 +894,25 @@ uint32_t target_c_type_size_in_bits(const ZigTarget *target, CIntType id) {
                 case CIntTypeCount:
                     zig_unreachable();
             }
+        case OsIOS:
+            switch (id) {
+                case CIntTypeShort:
+                case CIntTypeUShort:
+                    return 16;
+                case CIntTypeInt:
+                case CIntTypeUInt:
+                    return 32;
+                case CIntTypeLong:
+                case CIntTypeULong:
+                case CIntTypeLongLong:
+                case CIntTypeULongLong:
+                    return 64;
+                case CIntTypeCount:
+                    zig_unreachable();
+            }
         case OsAnanas:
         case OsCloudABI:
         case OsDragonFly:
-        case OsIOS:
         case OsKFreeBSD:
         case OsLv2:
         case OsSolaris:
@@ -950,6 +965,8 @@ const char *target_exe_file_ext(const ZigTarget *target) {
         return ".exe";
     } else if (target->os == OsUefi) {
         return ".efi";
+    } else if (target_is_wasm(target)) {
+        return ".wasm";
     } else {
         return "";
     }
@@ -1350,6 +1367,14 @@ bool target_is_musl(const ZigTarget *target) {
     return target->os == OsLinux && target_abi_is_musl(target->abi);
 }
 
+bool target_is_wasm(const ZigTarget *target) {
+    return target->arch == ZigLLVM_wasm32 || target->arch == ZigLLVM_wasm64;
+}
+
+bool target_is_single_threaded(const ZigTarget *target) {
+    return target_is_wasm(target);
+}
+
 ZigLLVM_EnvironmentType target_default_abi(ZigLLVM_ArchType arch, Os os) {
     switch (os) {
         case OsFreestanding:
diff --git a/src/target.hpp b/src/target.hpp
index 4a0264c2b1..fd5c7471c3 100644
--- a/src/target.hpp
+++ b/src/target.hpp
@@ -170,6 +170,8 @@ bool target_abi_is_gnu(ZigLLVM_EnvironmentType abi);
 bool target_abi_is_musl(ZigLLVM_EnvironmentType abi);
 bool target_is_glibc(const ZigTarget *target);
 bool target_is_musl(const ZigTarget *target);
+bool target_is_wasm(const ZigTarget *target);
+bool target_is_single_threaded(const ZigTarget *target);
 
 uint32_t target_arch_pointer_bit_width(ZigLLVM_ArchType arch);
 
diff --git a/src/translate_c.cpp b/src/translate_c.cpp
index 8abd66c0ff..c3c715cb47 100644
--- a/src/translate_c.cpp
+++ b/src/translate_c.cpp
@@ -76,10 +76,9 @@ struct TransScopeWhile {
 };
 
 struct Context {
-    ZigList<ErrorMsg *> *errors;
+    AstNode *root;
     VisibMod visib_mod;
     bool want_export;
-    AstNode *root;
     HashMap<const void *, AstNode *, ptr_hash, ptr_eq> decl_table;
     HashMap<Buf *, AstNode *, buf_hash, buf_eql_buf> macro_table;
     HashMap<Buf *, AstNode *, buf_hash, buf_eql_buf> global_table;
@@ -112,19 +111,39 @@ static TransScopeSwitch *trans_scope_switch_create(Context *c, TransScope *paren
 
 static TransScopeBlock *trans_scope_block_find(TransScope *scope);
 
-static AstNode *resolve_record_decl(Context *c, const clang::RecordDecl *record_decl);
-static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl);
-static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *typedef_decl);
+static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record_decl);
+static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl);
+static AstNode *resolve_typedef_decl(Context *c, const ZigClangTypedefNameDecl *typedef_decl);
 
-static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *stmt,
+static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *stmt,
         ResultUsed result_used, TransLRValue lrval,
         AstNode **out_node, TransScope **out_child_scope,
         TransScope **out_node_scope);
-static TransScope *trans_stmt(Context *c, TransScope *scope, const clang::Stmt *stmt, AstNode **out_node);
-static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval);
-static AstNode *trans_qual_type(Context *c, clang::QualType qt, const clang::SourceLocation &source_loc);
-static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval);
-static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::QualType qt, const clang::SourceLocation &source_loc);
+static TransScope *trans_stmt(Context *c, TransScope *scope, const ZigClangStmt *stmt, AstNode **out_node);
+static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval);
+static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc);
+static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc);
+static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope,
+        const ZigClangExpr *expr, TransLRValue lrval);
+static AstNode *trans_ap_value(Context *c, const ZigClangAPValue *ap_value, ZigClangQualType qt,
+        ZigClangSourceLocation source_loc);
+static bool c_is_unsigned_integer(Context *c, ZigClangQualType qt);
+
+static const ZigClangAPSInt *bitcast(const llvm::APSInt *src) {
+    return reinterpret_cast<const ZigClangAPSInt *>(src);
+}
+
+static const ZigClangAPValue *bitcast(const clang::APValue *src) {
+    return reinterpret_cast<const ZigClangAPValue *>(src);
+}
+
+static const ZigClangStmt *bitcast(const clang::Stmt *src) {
+    return reinterpret_cast<const ZigClangStmt *>(src);
+}
+
+static const ZigClangExpr *bitcast(const clang::Expr *src) {
+    return reinterpret_cast<const ZigClangExpr *>(src);
+}
 
 static ZigClangSourceLocation bitcast(clang::SourceLocation src) {
     ZigClangSourceLocation dest;
@@ -136,14 +155,14 @@ static ZigClangQualType bitcast(clang::QualType src) {
     memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangQualType));
     return dest;
 }
-static clang::QualType bitcast(ZigClangQualType src) {
-    clang::QualType dest;
-    memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangQualType));
-    return dest;
-}
+//static clang::QualType bitcast(ZigClangQualType src) {
+//    clang::QualType dest;
+//    memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangQualType));
+//    return dest;
+//}
 
 ATTRIBUTE_PRINTF(3, 4)
-static void emit_warning(Context *c, const clang::SourceLocation &clang_sl, const char *format, ...) {
+static void emit_warning(Context *c, ZigClangSourceLocation sl, const char *format, ...) {
     if (!c->warnings_on) {
         return;
     }
@@ -153,7 +172,6 @@ static void emit_warning(Context *c, const clang::SourceLocation &clang_sl, cons
     Buf *msg = buf_vprintf(format, ap);
     va_end(ap);
 
-    ZigClangSourceLocation sl = bitcast(clang_sl);
     const char *filename_bytes = ZigClangSourceManager_getFilename(c->source_manager,
             ZigClangSourceManager_getSpellingLoc(c->source_manager, sl));
     Buf *path;
@@ -489,107 +507,99 @@ static Buf *string_ref_to_buf(llvm::StringRef string_ref) {
     return buf_create_from_mem((const char *)string_ref.bytes_begin(), string_ref.size());
 }
 
-static const char *decl_name(const clang::Decl *decl) {
-    const clang::NamedDecl *named_decl = static_cast<const clang::NamedDecl *>(decl);
-    return (const char *)named_decl->getName().bytes_begin();
-}
-
-static AstNode *trans_create_node_apint(Context *c, const llvm::APSInt &aps_int) {
+static AstNode *trans_create_node_apint(Context *c, const ZigClangAPSInt *aps_int) {
     AstNode *node = trans_create_node(c, NodeTypeIntLiteral);
     node->data.int_literal.bigint = allocate<BigInt>(1);
-    bool is_negative = aps_int.isSigned() && aps_int.isNegative();
+    bool is_negative = ZigClangAPSInt_isSigned(aps_int) && ZigClangAPSInt_isNegative(aps_int);
     if (!is_negative) {
-        bigint_init_data(node->data.int_literal.bigint, aps_int.getRawData(), aps_int.getNumWords(), false);
+        bigint_init_data(node->data.int_literal.bigint,
+                ZigClangAPSInt_getRawData(aps_int),
+                ZigClangAPSInt_getNumWords(aps_int),
+                false);
         return node;
     }
-    llvm::APSInt negated = -aps_int;
-    bigint_init_data(node->data.int_literal.bigint, negated.getRawData(), negated.getNumWords(), true);
+    const ZigClangAPSInt *negated = ZigClangAPSInt_negate(aps_int);
+    bigint_init_data(node->data.int_literal.bigint, ZigClangAPSInt_getRawData(negated),
+            ZigClangAPSInt_getNumWords(negated), true);
+    ZigClangAPSInt_free(negated);
     return node;
+}
 
+static AstNode *trans_create_node_apfloat(Context *c, const llvm::APFloat &ap_float) {
+    uint8_t buf[128];
+    size_t written = ap_float.convertToHexString((char *)buf, 0, false,
+                                                 llvm::APFloat::rmNearestTiesToEven);
+    AstNode *node = trans_create_node(c, NodeTypeFloatLiteral);
+    node->data.float_literal.bigfloat = allocate<BigFloat>(1);
+    if (bigfloat_init_buf(node->data.float_literal.bigfloat, buf, written)) {
+        node->data.float_literal.overflow = true;
+    }
+    return node;
 }
 
-static const clang::Type *qual_type_canon(clang::QualType qt) {
-    return qt.getCanonicalType().getTypePtr();
+static const ZigClangType *qual_type_canon(ZigClangQualType qt) {
+    ZigClangQualType canon = ZigClangQualType_getCanonicalType(qt);
+    return ZigClangQualType_getTypePtr(canon);
 }
 
-static clang::QualType get_expr_qual_type(Context *c, const clang::Expr *expr) {
+static ZigClangQualType get_expr_qual_type(Context *c, const ZigClangExpr *expr) {
     // String literals in C are `char *` but they should really be `const char *`.
-    if (expr->getStmtClass() == clang::Stmt::ImplicitCastExprClass) {
-        const clang::ImplicitCastExpr *cast_expr = static_cast<const clang::ImplicitCastExpr *>(expr);
-        if (cast_expr->getCastKind() == clang::CK_ArrayToPointerDecay) {
-            const clang::Expr *sub_expr = cast_expr->getSubExpr();
-            if (sub_expr->getStmtClass() == clang::Stmt::StringLiteralClass) {
-                clang::QualType array_qt = sub_expr->getType();
-                const clang::ArrayType *array_type = static_cast<const clang::ArrayType *>(array_qt.getTypePtr());
-                clang::QualType pointee_qt = array_type->getElementType();
-                pointee_qt.addConst();
-                return bitcast(ZigClangASTContext_getPointerType(c->ctx, bitcast(pointee_qt)));
+    if (ZigClangExpr_getStmtClass(expr) == ZigClangStmt_ImplicitCastExprClass) {
+        const clang::ImplicitCastExpr *cast_expr = reinterpret_cast<const clang::ImplicitCastExpr *>(expr);
+        if ((ZigClangCK)cast_expr->getCastKind() == ZigClangCK_ArrayToPointerDecay) {
+            const ZigClangExpr *sub_expr = bitcast(cast_expr->getSubExpr());
+            if (ZigClangExpr_getStmtClass(sub_expr) == ZigClangStmt_StringLiteralClass) {
+                ZigClangQualType array_qt = ZigClangExpr_getType(sub_expr);
+                const clang::ArrayType *array_type = reinterpret_cast<const clang::ArrayType *>(
+                        ZigClangQualType_getTypePtr(array_qt));
+                ZigClangQualType pointee_qt = bitcast(array_type->getElementType());
+                ZigClangQualType_addConst(&pointee_qt);
+                return ZigClangASTContext_getPointerType(c->ctx, pointee_qt);
             }
         }
     }
-    return expr->getType();
+    return ZigClangExpr_getType(expr);
 }
 
-static clang::QualType get_expr_qual_type_before_implicit_cast(Context *c, const clang::Expr *expr) {
-    if (expr->getStmtClass() == clang::Stmt::ImplicitCastExprClass) {
-        const clang::ImplicitCastExpr *cast_expr = static_cast<const clang::ImplicitCastExpr *>(expr);
-        return get_expr_qual_type(c, cast_expr->getSubExpr());
+static ZigClangQualType get_expr_qual_type_before_implicit_cast(Context *c, const ZigClangExpr *expr) {
+    if (ZigClangExpr_getStmtClass(expr) == ZigClangStmt_ImplicitCastExprClass) {
+        const clang::ImplicitCastExpr *cast_expr = reinterpret_cast<const clang::ImplicitCastExpr *>(expr);
+        return get_expr_qual_type(c, bitcast(cast_expr->getSubExpr()));
     }
-    return expr->getType();
+    return ZigClangExpr_getType(expr);
 }
 
-static AstNode *get_expr_type(Context *c, const clang::Expr *expr) {
-    return trans_qual_type(c, get_expr_qual_type(c, expr), expr->getBeginLoc());
-}
-
-static bool qual_types_equal(clang::QualType t1, clang::QualType t2) {
-    if (t1.isConstQualified() != t2.isConstQualified()) {
-        return false;
-    }
-    if (t1.isVolatileQualified() != t2.isVolatileQualified()) {
-        return false;
-    }
-    if (t1.isRestrictQualified() != t2.isRestrictQualified()) {
-        return false;
-    }
-    return t1.getTypePtr() == t2.getTypePtr();
+static AstNode *get_expr_type(Context *c, const ZigClangExpr *expr) {
+    return trans_qual_type(c, get_expr_qual_type(c, expr), ZigClangExpr_getBeginLoc(expr));
 }
 
 static bool is_c_void_type(AstNode *node) {
     return (node->type == NodeTypeSymbol && buf_eql_str(node->data.symbol_expr.symbol, "c_void"));
 }
 
-static bool expr_types_equal(Context *c, const clang::Expr *expr1, const clang::Expr *expr2) {
-    clang::QualType t1 = get_expr_qual_type(c, expr1);
-    clang::QualType t2 = get_expr_qual_type(c, expr2);
-
-    return qual_types_equal(t1, t2);
+static bool qual_type_is_ptr(ZigClangQualType qt) {
+    const ZigClangType *ty = qual_type_canon(qt);
+    return ZigClangType_getTypeClass(ty) == ZigClangType_Pointer;
 }
 
-static bool qual_type_is_ptr(clang::QualType qt) {
-    const clang::Type *ty = qual_type_canon(qt);
-    return ty->getTypeClass() == clang::Type::Pointer;
-}
-
-static const clang::FunctionProtoType *qual_type_get_fn_proto(clang::QualType qt, bool *is_ptr) {
-    const clang::Type *ty = qual_type_canon(qt);
+static const clang::FunctionProtoType *qual_type_get_fn_proto(ZigClangQualType qt, bool *is_ptr) {
+    const ZigClangType *ty = qual_type_canon(qt);
     *is_ptr = false;
 
-    if (ty->getTypeClass() == clang::Type::Pointer) {
+    if (ZigClangType_getTypeClass(ty) == ZigClangType_Pointer) {
         *is_ptr = true;
-        const clang::PointerType *pointer_ty = static_cast<const clang::PointerType*>(ty);
-        clang::QualType child_qt = pointer_ty->getPointeeType();
-        ty = child_qt.getTypePtr();
+        ZigClangQualType child_qt = ZigClangType_getPointeeType(ty);
+        ty = ZigClangQualType_getTypePtr(child_qt);
     }
 
-    if (ty->getTypeClass() == clang::Type::FunctionProto) {
-        return static_cast<const clang::FunctionProtoType*>(ty);
+    if (ZigClangType_getTypeClass(ty) == ZigClangType_FunctionProto) {
+        return reinterpret_cast<const clang::FunctionProtoType*>(ty);
     }
 
     return nullptr;
 }
 
-static bool qual_type_is_fn_ptr(clang::QualType qt) {
+static bool qual_type_is_fn_ptr(ZigClangQualType qt) {
     bool is_ptr;
     if (qual_type_get_fn_proto(qt, &is_ptr)) {
         return is_ptr;
@@ -598,31 +608,31 @@ static bool qual_type_is_fn_ptr(clang::QualType qt) {
     return false;
 }
 
-static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType &qt, const clang::SourceLocation &source_loc) {
-    const clang::Type *ty = qt.getTypePtr();
-    switch (ty->getTypeClass()) {
-        case clang::Type::Builtin:
+static uint32_t qual_type_int_bit_width(Context *c, const ZigClangQualType qt, ZigClangSourceLocation source_loc) {
+    const ZigClangType *ty = ZigClangQualType_getTypePtr(qt);
+    switch (ZigClangType_getTypeClass(ty)) {
+        case ZigClangType_Builtin:
             {
-                const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(ty);
-                switch (builtin_ty->getKind()) {
-                    case clang::BuiltinType::Char_U:
-                    case clang::BuiltinType::UChar:
-                    case clang::BuiltinType::Char_S:
-                    case clang::BuiltinType::SChar:
+                const ZigClangBuiltinType *builtin_ty = reinterpret_cast<const ZigClangBuiltinType*>(ty);
+                switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+                    case ZigClangBuiltinTypeChar_U:
+                    case ZigClangBuiltinTypeUChar:
+                    case ZigClangBuiltinTypeChar_S:
+                    case ZigClangBuiltinTypeSChar:
                         return 8;
-                    case clang::BuiltinType::UInt128:
-                    case clang::BuiltinType::Int128:
+                    case ZigClangBuiltinTypeUInt128:
+                    case ZigClangBuiltinTypeInt128:
                         return 128;
                     default:
                         return 0;
                 }
                 zig_unreachable();
             }
-        case clang::Type::Typedef:
+        case ZigClangType_Typedef:
             {
-                const clang::TypedefType *typedef_ty = static_cast<const clang::TypedefType*>(ty);
-                const clang::TypedefNameDecl *typedef_decl = typedef_ty->getDecl();
-                const char *type_name = decl_name(typedef_decl);
+                const ZigClangTypedefType *typedef_ty = reinterpret_cast<const ZigClangTypedefType*>(ty);
+                const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
+                const char *type_name = ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)typedef_decl);
                 if (strcmp(type_name, "uint8_t") == 0 || strcmp(type_name, "int8_t") == 0) {
                     return 8;
                 } else if (strcmp(type_name, "uint16_t") == 0 || strcmp(type_name, "int16_t") == 0) {
@@ -642,8 +652,8 @@ static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType &qt, c
 }
 
 
-static AstNode *qual_type_to_log2_int_ref(Context *c, const clang::QualType &qt,
-        const clang::SourceLocation &source_loc)
+static AstNode *qual_type_to_log2_int_ref(Context *c, const ZigClangQualType qt,
+        ZigClangSourceLocation source_loc)
 {
     uint32_t int_bit_width = qual_type_int_bit_width(c, qt, source_loc);
     if (int_bit_width != 0) {
@@ -675,37 +685,76 @@ static AstNode *qual_type_to_log2_int_ref(Context *c, const clang::QualType &qt,
     return log2int_fn_call;
 }
 
-static bool qual_type_child_is_fn_proto(const clang::QualType &qt) {
-    if (qt.getTypePtr()->getTypeClass() == clang::Type::Paren) {
-        const clang::ParenType *paren_type = static_cast<const clang::ParenType *>(qt.getTypePtr());
+static bool qual_type_child_is_fn_proto(ZigClangQualType qt) {
+    const ZigClangType *ty = ZigClangQualType_getTypePtr(qt);
+    if (ZigClangType_getTypeClass(ty) == ZigClangType_Paren) {
+        const clang::ParenType *paren_type = reinterpret_cast<const clang::ParenType *>(ty);
         if (paren_type->getInnerType()->getTypeClass() == clang::Type::FunctionProto) {
             return true;
         }
-    } else if (qt.getTypePtr()->getTypeClass() == clang::Type::Attributed) {
-        const clang::AttributedType *attr_type = static_cast<const clang::AttributedType *>(qt.getTypePtr());
-        return qual_type_child_is_fn_proto(attr_type->getEquivalentType());
+    } else if (ZigClangType_getTypeClass(ty) == ZigClangType_Attributed) {
+        const clang::AttributedType *attr_type = reinterpret_cast<const clang::AttributedType *>(ty);
+        return qual_type_child_is_fn_proto(bitcast(attr_type->getEquivalentType()));
     }
     return false;
 }
 
-static AstNode* trans_c_cast(Context *c, const clang::SourceLocation &source_location, clang::QualType dest_type,
-        clang::QualType src_type, AstNode *expr)
+static AstNode* trans_c_ptr_cast(Context *c, ZigClangSourceLocation source_location, ZigClangQualType dest_type,
+                                 ZigClangQualType src_type, AstNode *expr)
+{
+    const ZigClangType *ty = ZigClangQualType_getTypePtr(dest_type);
+    const ZigClangQualType child_type = ZigClangType_getPointeeType(ty);
+
+    AstNode *dest_type_node = trans_type(c, ty, source_location);
+    AstNode *child_type_node = trans_qual_type(c, child_type, source_location);
+
+    // Implicit downcasting from higher to lower alignment values is forbidden,
+    // use @alignCast to side-step this problem
+    AstNode *ptrcast_node = trans_create_node_builtin_fn_call_str(c, "ptrCast");
+    ptrcast_node->data.fn_call_expr.params.append(dest_type_node);
+
+    if (ZigClangType_isVoidType(qual_type_canon(child_type))) {
+        // void has 1-byte alignment
+        ptrcast_node->data.fn_call_expr.params.append(expr);
+    } else {
+        AstNode *alignof_node = trans_create_node_builtin_fn_call_str(c, "alignOf");
+        alignof_node->data.fn_call_expr.params.append(child_type_node);
+        AstNode *aligncast_node = trans_create_node_builtin_fn_call_str(c, "alignCast");
+        aligncast_node->data.fn_call_expr.params.append(alignof_node);
+        aligncast_node->data.fn_call_expr.params.append(expr);
+
+        ptrcast_node->data.fn_call_expr.params.append(aligncast_node);
+    }
+
+    return ptrcast_node;
+}
+
+static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, ZigClangQualType dest_type,
+        ZigClangQualType src_type, AstNode *expr)
 {
     // The only way void pointer casts are valid C code, is if
     // the value of the expression is ignored. We therefore just
     // return the expr, and let the system that ignores values
     // translate this correctly.
-    if (qual_type_canon(dest_type)->isVoidType()) {
+    if (ZigClangType_isVoidType(qual_type_canon(dest_type))) {
         return expr;
     }
-    if (qual_types_equal(dest_type, src_type)) {
+    if (ZigClangQualType_eq(dest_type, src_type)) {
         return expr;
     }
     if (qual_type_is_ptr(dest_type) && qual_type_is_ptr(src_type)) {
-        AstNode *ptr_cast_node = trans_create_node_builtin_fn_call_str(c, "ptrCast");
-        ptr_cast_node->data.fn_call_expr.params.append(trans_qual_type(c, dest_type, source_location));
-        ptr_cast_node->data.fn_call_expr.params.append(expr);
-        return ptr_cast_node;
+        return trans_c_ptr_cast(c, source_location, dest_type, src_type, expr);
+    }
+    if (c_is_unsigned_integer(c, dest_type) && qual_type_is_ptr(src_type)) {
+        AstNode *addr_node = trans_create_node_builtin_fn_call_str(c, "ptrToInt");
+        addr_node->data.fn_call_expr.params.append(expr);
+        return trans_create_node_fn_call_1(c, trans_qual_type(c, dest_type, source_location), addr_node);
+    }
+    if (c_is_unsigned_integer(c, src_type) && qual_type_is_ptr(dest_type)) {
+        AstNode *ptr_node = trans_create_node_builtin_fn_call_str(c, "intToPtr");
+        ptr_node->data.fn_call_expr.params.append(trans_qual_type(c, dest_type, source_location));
+        ptr_node->data.fn_call_expr.params.append(expr);
+        return ptr_node;
     }
     // TODO: maybe widen to increase size
     // TODO: maybe bitcast to change sign
@@ -713,72 +762,72 @@ static AstNode* trans_c_cast(Context *c, const clang::SourceLocation &source_loc
     return trans_create_node_fn_call_1(c, trans_qual_type(c, dest_type, source_location), expr);
 }
 
-static bool c_is_signed_integer(Context *c, clang::QualType qt) {
-    const clang::Type *c_type = qual_type_canon(qt);
-    if (c_type->getTypeClass() != clang::Type::Builtin)
+static bool c_is_signed_integer(Context *c, ZigClangQualType qt) {
+    const ZigClangType *c_type = qual_type_canon(qt);
+    if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin)
         return false;
-    const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(c_type);
-    switch (builtin_ty->getKind()) {
-        case clang::BuiltinType::SChar:
-        case clang::BuiltinType::Short:
-        case clang::BuiltinType::Int:
-        case clang::BuiltinType::Long:
-        case clang::BuiltinType::LongLong:
-        case clang::BuiltinType::Int128:
-        case clang::BuiltinType::WChar_S:
+    const ZigClangBuiltinType *builtin_ty = reinterpret_cast<const ZigClangBuiltinType*>(c_type);
+    switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+        case ZigClangBuiltinTypeSChar:
+        case ZigClangBuiltinTypeShort:
+        case ZigClangBuiltinTypeInt:
+        case ZigClangBuiltinTypeLong:
+        case ZigClangBuiltinTypeLongLong:
+        case ZigClangBuiltinTypeInt128:
+        case ZigClangBuiltinTypeWChar_S:
             return true;
         default:
             return false;
     }
 }
 
-static bool c_is_unsigned_integer(Context *c, clang::QualType qt) {
-    const clang::Type *c_type = qual_type_canon(qt);
-    if (c_type->getTypeClass() != clang::Type::Builtin)
+static bool c_is_unsigned_integer(Context *c, ZigClangQualType qt) {
+    const ZigClangType *c_type = qual_type_canon(qt);
+    if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin)
         return false;
-    const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(c_type);
-    switch (builtin_ty->getKind()) {
-        case clang::BuiltinType::Char_U:
-        case clang::BuiltinType::UChar:
-        case clang::BuiltinType::Char_S:
-        case clang::BuiltinType::UShort:
-        case clang::BuiltinType::UInt:
-        case clang::BuiltinType::ULong:
-        case clang::BuiltinType::ULongLong:
-        case clang::BuiltinType::UInt128:
-        case clang::BuiltinType::WChar_U:
+    const ZigClangBuiltinType *builtin_ty = reinterpret_cast<const ZigClangBuiltinType*>(c_type);
+    switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+        case ZigClangBuiltinTypeChar_U:
+        case ZigClangBuiltinTypeUChar:
+        case ZigClangBuiltinTypeChar_S:
+        case ZigClangBuiltinTypeUShort:
+        case ZigClangBuiltinTypeUInt:
+        case ZigClangBuiltinTypeULong:
+        case ZigClangBuiltinTypeULongLong:
+        case ZigClangBuiltinTypeUInt128:
+        case ZigClangBuiltinTypeWChar_U:
             return true;
         default:
             return false;
     }
 }
 
-static bool c_is_builtin_type(Context *c, clang::QualType qt, clang::BuiltinType::Kind kind) {
-    const clang::Type *c_type = qual_type_canon(qt);
-    if (c_type->getTypeClass() != clang::Type::Builtin)
+static bool c_is_builtin_type(Context *c, ZigClangQualType qt, ZigClangBuiltinTypeKind kind) {
+    const ZigClangType *c_type = qual_type_canon(qt);
+    if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin)
         return false;
-    const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(c_type);
-    return builtin_ty->getKind() == kind;
+    const ZigClangBuiltinType *builtin_ty = reinterpret_cast<const ZigClangBuiltinType*>(c_type);
+    return ZigClangBuiltinType_getKind(builtin_ty) == kind;
 }
 
-static bool c_is_float(Context *c, clang::QualType qt) {
-    const clang::Type *c_type = qt.getTypePtr();
-    if (c_type->getTypeClass() != clang::Type::Builtin)
+static bool c_is_float(Context *c, ZigClangQualType qt) {
+    const ZigClangType *c_type = ZigClangQualType_getTypePtr(qt);
+    if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin)
         return false;
-    const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(c_type);
-    switch (builtin_ty->getKind()) {
-        case clang::BuiltinType::Half:
-        case clang::BuiltinType::Float:
-        case clang::BuiltinType::Double:
-        case clang::BuiltinType::Float128:
-        case clang::BuiltinType::LongDouble:
+    const ZigClangBuiltinType *builtin_ty = reinterpret_cast<const ZigClangBuiltinType*>(c_type);
+    switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+        case ZigClangBuiltinTypeHalf:
+        case ZigClangBuiltinTypeFloat:
+        case ZigClangBuiltinTypeDouble:
+        case ZigClangBuiltinTypeFloat128:
+        case ZigClangBuiltinTypeLongDouble:
             return true;
         default:
             return false;
     }
 }
 
-static bool qual_type_has_wrapping_overflow(Context *c, clang::QualType qt) {
+static bool qual_type_has_wrapping_overflow(Context *c, ZigClangQualType qt) {
     if (c_is_signed_integer(c, qt) || c_is_float(c, qt)) {
         // float and signed integer overflow is undefined behavior.
         return false;
@@ -788,181 +837,182 @@ static bool qual_type_has_wrapping_overflow(Context *c, clang::QualType qt) {
     }
 }
 
-static bool type_is_opaque(Context *c, const clang::Type *ty, const clang::SourceLocation &source_loc) {
-    switch (ty->getTypeClass()) {
-        case clang::Type::Builtin: {
-            const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(ty);
-            return builtin_ty->getKind() == clang::BuiltinType::Void;
+static bool type_is_opaque(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc) {
+    switch (ZigClangType_getTypeClass(ty)) {
+        case ZigClangType_Builtin: {
+            const ZigClangBuiltinType *builtin_ty = reinterpret_cast<const ZigClangBuiltinType*>(ty);
+            return ZigClangBuiltinType_getKind(builtin_ty) == ZigClangBuiltinTypeVoid;
         }
-        case clang::Type::Record: {
-            const clang::RecordType *record_ty = static_cast<const clang::RecordType*>(ty);
+        case ZigClangType_Record: {
+            const clang::RecordType *record_ty = reinterpret_cast<const clang::RecordType*>(ty);
             return record_ty->getDecl()->getDefinition() == nullptr;
         }
-        case clang::Type::Elaborated: {
-            const clang::ElaboratedType *elaborated_ty = static_cast<const clang::ElaboratedType*>(ty);
-            return type_is_opaque(c, elaborated_ty->getNamedType().getTypePtr(), source_loc);
+        case ZigClangType_Elaborated: {
+            const clang::ElaboratedType *elaborated_ty = reinterpret_cast<const clang::ElaboratedType*>(ty);
+            ZigClangQualType qt = bitcast(elaborated_ty->getNamedType());
+            return type_is_opaque(c, ZigClangQualType_getTypePtr(qt), source_loc);
         }
-        case clang::Type::Typedef: {
-            const clang::TypedefType *typedef_ty = static_cast<const clang::TypedefType*>(ty);
-            const clang::TypedefNameDecl *typedef_decl = typedef_ty->getDecl();
-            return type_is_opaque(c, typedef_decl->getUnderlyingType().getTypePtr(), source_loc);
+        case ZigClangType_Typedef: {
+            const ZigClangTypedefType *typedef_ty = reinterpret_cast<const ZigClangTypedefType*>(ty);
+            const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
+            ZigClangQualType underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
+            return type_is_opaque(c, ZigClangQualType_getTypePtr(underlying_type), source_loc);
         }
         default:
             return false;
     }
 }
 
-static AstNode *trans_type(Context *c, const clang::Type *ty, const clang::SourceLocation &source_loc) {
-    switch (ty->getTypeClass()) {
-        case clang::Type::Builtin:
+static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc) {
+    switch (ZigClangType_getTypeClass(ty)) {
+        case ZigClangType_Builtin:
             {
-                const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(ty);
-                switch (builtin_ty->getKind()) {
-                    case clang::BuiltinType::Void:
+                const ZigClangBuiltinType *builtin_ty = reinterpret_cast<const ZigClangBuiltinType *>(ty);
+                switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+                    case ZigClangBuiltinTypeVoid:
                         return trans_create_node_symbol_str(c, "c_void");
-                    case clang::BuiltinType::Bool:
+                    case ZigClangBuiltinTypeBool:
                         return trans_create_node_symbol_str(c, "bool");
-                    case clang::BuiltinType::Char_U:
-                    case clang::BuiltinType::UChar:
-                    case clang::BuiltinType::Char_S:
-                    case clang::BuiltinType::Char8:
+                    case ZigClangBuiltinTypeChar_U:
+                    case ZigClangBuiltinTypeUChar:
+                    case ZigClangBuiltinTypeChar_S:
+                    case ZigClangBuiltinTypeChar8:
                         return trans_create_node_symbol_str(c, "u8");
-                    case clang::BuiltinType::SChar:
+                    case ZigClangBuiltinTypeSChar:
                         return trans_create_node_symbol_str(c, "i8");
-                    case clang::BuiltinType::UShort:
+                    case ZigClangBuiltinTypeUShort:
                         return trans_create_node_symbol_str(c, "c_ushort");
-                    case clang::BuiltinType::UInt:
+                    case ZigClangBuiltinTypeUInt:
                         return trans_create_node_symbol_str(c, "c_uint");
-                    case clang::BuiltinType::ULong:
+                    case ZigClangBuiltinTypeULong:
                         return trans_create_node_symbol_str(c, "c_ulong");
-                    case clang::BuiltinType::ULongLong:
+                    case ZigClangBuiltinTypeULongLong:
                         return trans_create_node_symbol_str(c, "c_ulonglong");
-                    case clang::BuiltinType::Short:
+                    case ZigClangBuiltinTypeShort:
                         return trans_create_node_symbol_str(c, "c_short");
-                    case clang::BuiltinType::Int:
+                    case ZigClangBuiltinTypeInt:
                         return trans_create_node_symbol_str(c, "c_int");
-                    case clang::BuiltinType::Long:
+                    case ZigClangBuiltinTypeLong:
                         return trans_create_node_symbol_str(c, "c_long");
-                    case clang::BuiltinType::LongLong:
+                    case ZigClangBuiltinTypeLongLong:
                         return trans_create_node_symbol_str(c, "c_longlong");
-                    case clang::BuiltinType::UInt128:
+                    case ZigClangBuiltinTypeUInt128:
                         return trans_create_node_symbol_str(c, "u128");
-                    case clang::BuiltinType::Int128:
+                    case ZigClangBuiltinTypeInt128:
                         return trans_create_node_symbol_str(c, "i128");
-                    case clang::BuiltinType::Float:
+                    case ZigClangBuiltinTypeFloat:
                         return trans_create_node_symbol_str(c, "f32");
-                    case clang::BuiltinType::Double:
+                    case ZigClangBuiltinTypeDouble:
                         return trans_create_node_symbol_str(c, "f64");
-                    case clang::BuiltinType::Float128:
+                    case ZigClangBuiltinTypeFloat128:
                         return trans_create_node_symbol_str(c, "f128");
-                    case clang::BuiltinType::Float16:
+                    case ZigClangBuiltinTypeFloat16:
                         return trans_create_node_symbol_str(c, "f16");
-                    case clang::BuiltinType::LongDouble:
+                    case ZigClangBuiltinTypeLongDouble:
                         return trans_create_node_symbol_str(c, "c_longdouble");
-                    case clang::BuiltinType::WChar_U:
-                    case clang::BuiltinType::Char16:
-                    case clang::BuiltinType::Char32:
-                    case clang::BuiltinType::WChar_S:
-                    case clang::BuiltinType::Half:
-                    case clang::BuiltinType::NullPtr:
-                    case clang::BuiltinType::ObjCId:
-                    case clang::BuiltinType::ObjCClass:
-                    case clang::BuiltinType::ObjCSel:
-                    case clang::BuiltinType::OMPArraySection:
-                    case clang::BuiltinType::Dependent:
-                    case clang::BuiltinType::Overload:
-                    case clang::BuiltinType::BoundMember:
-                    case clang::BuiltinType::PseudoObject:
-                    case clang::BuiltinType::UnknownAny:
-                    case clang::BuiltinType::BuiltinFn:
-                    case clang::BuiltinType::ARCUnbridgedCast:
-                    case clang::BuiltinType::ShortAccum:
-                    case clang::BuiltinType::Accum:
-                    case clang::BuiltinType::LongAccum:
-                    case clang::BuiltinType::UShortAccum:
-                    case clang::BuiltinType::UAccum:
-                    case clang::BuiltinType::ULongAccum:
-
-                    case clang::BuiltinType::OCLImage1dRO:
-                    case clang::BuiltinType::OCLImage1dArrayRO:
-                    case clang::BuiltinType::OCLImage1dBufferRO:
-                    case clang::BuiltinType::OCLImage2dRO:
-                    case clang::BuiltinType::OCLImage2dArrayRO:
-                    case clang::BuiltinType::OCLImage2dDepthRO:
-                    case clang::BuiltinType::OCLImage2dArrayDepthRO:
-                    case clang::BuiltinType::OCLImage2dMSAARO:
-                    case clang::BuiltinType::OCLImage2dArrayMSAARO:
-                    case clang::BuiltinType::OCLImage2dMSAADepthRO:
-                    case clang::BuiltinType::OCLImage2dArrayMSAADepthRO:
-                    case clang::BuiltinType::OCLImage3dRO:
-                    case clang::BuiltinType::OCLImage1dWO:
-                    case clang::BuiltinType::OCLImage1dArrayWO:
-                    case clang::BuiltinType::OCLImage1dBufferWO:
-                    case clang::BuiltinType::OCLImage2dWO:
-                    case clang::BuiltinType::OCLImage2dArrayWO:
-                    case clang::BuiltinType::OCLImage2dDepthWO:
-                    case clang::BuiltinType::OCLImage2dArrayDepthWO:
-                    case clang::BuiltinType::OCLImage2dMSAAWO:
-                    case clang::BuiltinType::OCLImage2dArrayMSAAWO:
-                    case clang::BuiltinType::OCLImage2dMSAADepthWO:
-                    case clang::BuiltinType::OCLImage2dArrayMSAADepthWO:
-                    case clang::BuiltinType::OCLImage3dWO:
-                    case clang::BuiltinType::OCLImage1dRW:
-                    case clang::BuiltinType::OCLImage1dArrayRW:
-                    case clang::BuiltinType::OCLImage1dBufferRW:
-                    case clang::BuiltinType::OCLImage2dRW:
-                    case clang::BuiltinType::OCLImage2dArrayRW:
-                    case clang::BuiltinType::OCLImage2dDepthRW:
-                    case clang::BuiltinType::OCLImage2dArrayDepthRW:
-                    case clang::BuiltinType::OCLImage2dMSAARW:
-                    case clang::BuiltinType::OCLImage2dArrayMSAARW:
-                    case clang::BuiltinType::OCLImage2dMSAADepthRW:
-                    case clang::BuiltinType::OCLImage2dArrayMSAADepthRW:
-                    case clang::BuiltinType::OCLImage3dRW:
-                    case clang::BuiltinType::OCLSampler:
-                    case clang::BuiltinType::OCLEvent:
-                    case clang::BuiltinType::OCLClkEvent:
-                    case clang::BuiltinType::OCLQueue:
-                    case clang::BuiltinType::OCLReserveID:
-                    case clang::BuiltinType::ShortFract:
-                    case clang::BuiltinType::Fract:
-                    case clang::BuiltinType::LongFract:
-                    case clang::BuiltinType::UShortFract:
-                    case clang::BuiltinType::UFract:
-                    case clang::BuiltinType::ULongFract:
-                    case clang::BuiltinType::SatShortAccum:
-                    case clang::BuiltinType::SatAccum:
-                    case clang::BuiltinType::SatLongAccum:
-                    case clang::BuiltinType::SatUShortAccum:
-                    case clang::BuiltinType::SatUAccum:
-                    case clang::BuiltinType::SatULongAccum:
-                    case clang::BuiltinType::SatShortFract:
-                    case clang::BuiltinType::SatFract:
-                    case clang::BuiltinType::SatLongFract:
-                    case clang::BuiltinType::SatUShortFract:
-                    case clang::BuiltinType::SatUFract:
-                    case clang::BuiltinType::SatULongFract:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCImePayload:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCMceResult:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCImeResult:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCRefResult:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCSicResult:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin:
-                    case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin:
+                    case ZigClangBuiltinTypeWChar_U:
+                    case ZigClangBuiltinTypeChar16:
+                    case ZigClangBuiltinTypeChar32:
+                    case ZigClangBuiltinTypeWChar_S:
+                    case ZigClangBuiltinTypeHalf:
+                    case ZigClangBuiltinTypeNullPtr:
+                    case ZigClangBuiltinTypeObjCId:
+                    case ZigClangBuiltinTypeObjCClass:
+                    case ZigClangBuiltinTypeObjCSel:
+                    case ZigClangBuiltinTypeOMPArraySection:
+                    case ZigClangBuiltinTypeDependent:
+                    case ZigClangBuiltinTypeOverload:
+                    case ZigClangBuiltinTypeBoundMember:
+                    case ZigClangBuiltinTypePseudoObject:
+                    case ZigClangBuiltinTypeUnknownAny:
+                    case ZigClangBuiltinTypeBuiltinFn:
+                    case ZigClangBuiltinTypeARCUnbridgedCast:
+                    case ZigClangBuiltinTypeShortAccum:
+                    case ZigClangBuiltinTypeAccum:
+                    case ZigClangBuiltinTypeLongAccum:
+                    case ZigClangBuiltinTypeUShortAccum:
+                    case ZigClangBuiltinTypeUAccum:
+                    case ZigClangBuiltinTypeULongAccum:
+
+                    case ZigClangBuiltinTypeOCLImage1dRO:
+                    case ZigClangBuiltinTypeOCLImage1dArrayRO:
+                    case ZigClangBuiltinTypeOCLImage1dBufferRO:
+                    case ZigClangBuiltinTypeOCLImage2dRO:
+                    case ZigClangBuiltinTypeOCLImage2dArrayRO:
+                    case ZigClangBuiltinTypeOCLImage2dDepthRO:
+                    case ZigClangBuiltinTypeOCLImage2dArrayDepthRO:
+                    case ZigClangBuiltinTypeOCLImage2dMSAARO:
+                    case ZigClangBuiltinTypeOCLImage2dArrayMSAARO:
+                    case ZigClangBuiltinTypeOCLImage2dMSAADepthRO:
+                    case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRO:
+                    case ZigClangBuiltinTypeOCLImage3dRO:
+                    case ZigClangBuiltinTypeOCLImage1dWO:
+                    case ZigClangBuiltinTypeOCLImage1dArrayWO:
+                    case ZigClangBuiltinTypeOCLImage1dBufferWO:
+                    case ZigClangBuiltinTypeOCLImage2dWO:
+                    case ZigClangBuiltinTypeOCLImage2dArrayWO:
+                    case ZigClangBuiltinTypeOCLImage2dDepthWO:
+                    case ZigClangBuiltinTypeOCLImage2dArrayDepthWO:
+                    case ZigClangBuiltinTypeOCLImage2dMSAAWO:
+                    case ZigClangBuiltinTypeOCLImage2dArrayMSAAWO:
+                    case ZigClangBuiltinTypeOCLImage2dMSAADepthWO:
+                    case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthWO:
+                    case ZigClangBuiltinTypeOCLImage3dWO:
+                    case ZigClangBuiltinTypeOCLImage1dRW:
+                    case ZigClangBuiltinTypeOCLImage1dArrayRW:
+                    case ZigClangBuiltinTypeOCLImage1dBufferRW:
+                    case ZigClangBuiltinTypeOCLImage2dRW:
+                    case ZigClangBuiltinTypeOCLImage2dArrayRW:
+                    case ZigClangBuiltinTypeOCLImage2dDepthRW:
+                    case ZigClangBuiltinTypeOCLImage2dArrayDepthRW:
+                    case ZigClangBuiltinTypeOCLImage2dMSAARW:
+                    case ZigClangBuiltinTypeOCLImage2dArrayMSAARW:
+                    case ZigClangBuiltinTypeOCLImage2dMSAADepthRW:
+                    case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRW:
+                    case ZigClangBuiltinTypeOCLImage3dRW:
+                    case ZigClangBuiltinTypeOCLSampler:
+                    case ZigClangBuiltinTypeOCLEvent:
+                    case ZigClangBuiltinTypeOCLClkEvent:
+                    case ZigClangBuiltinTypeOCLQueue:
+                    case ZigClangBuiltinTypeOCLReserveID:
+                    case ZigClangBuiltinTypeShortFract:
+                    case ZigClangBuiltinTypeFract:
+                    case ZigClangBuiltinTypeLongFract:
+                    case ZigClangBuiltinTypeUShortFract:
+                    case ZigClangBuiltinTypeUFract:
+                    case ZigClangBuiltinTypeULongFract:
+                    case ZigClangBuiltinTypeSatShortAccum:
+                    case ZigClangBuiltinTypeSatAccum:
+                    case ZigClangBuiltinTypeSatLongAccum:
+                    case ZigClangBuiltinTypeSatUShortAccum:
+                    case ZigClangBuiltinTypeSatUAccum:
+                    case ZigClangBuiltinTypeSatULongAccum:
+                    case ZigClangBuiltinTypeSatShortFract:
+                    case ZigClangBuiltinTypeSatFract:
+                    case ZigClangBuiltinTypeSatLongFract:
+                    case ZigClangBuiltinTypeSatUShortFract:
+                    case ZigClangBuiltinTypeSatUFract:
+                    case ZigClangBuiltinTypeSatULongFract:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCMcePayload:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCImePayload:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCRefPayload:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCSicPayload:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCMceResult:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResult:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCRefResult:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCSicResult:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultSingleRefStreamout:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultDualRefStreamout:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeSingleRefStreamin:
+                    case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeDualRefStreamin:
                         emit_warning(c, source_loc, "unsupported builtin type");
                         return nullptr;
                 }
                 break;
             }
-        case clang::Type::Pointer:
+        case ZigClangType_Pointer:
             {
-                const clang::PointerType *pointer_ty = static_cast<const clang::PointerType*>(ty);
-                clang::QualType child_qt = pointer_ty->getPointeeType();
+                ZigClangQualType child_qt = ZigClangType_getPointeeType(ty);
                 AstNode *child_node = trans_qual_type(c, child_qt, source_loc);
                 if (child_node == nullptr) {
                     emit_warning(c, source_loc, "pointer to unsupported type");
@@ -973,29 +1023,33 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, const clang::Sourc
                     return trans_create_node_prefix_op(c, PrefixOpOptional, child_node);
                 }
 
-                if (type_is_opaque(c, child_qt.getTypePtr(), source_loc)) {
-                    AstNode *pointer_node = trans_create_node_ptr_type(c, child_qt.isConstQualified(),
-                            child_qt.isVolatileQualified(), child_node, PtrLenSingle);
+                if (type_is_opaque(c, ZigClangQualType_getTypePtr(child_qt), source_loc)) {
+                    AstNode *pointer_node = trans_create_node_ptr_type(c,
+                            ZigClangQualType_isConstQualified(child_qt),
+                            ZigClangQualType_isVolatileQualified(child_qt),
+                            child_node, PtrLenSingle);
                     return trans_create_node_prefix_op(c, PrefixOpOptional, pointer_node);
                 } else {
-                    return trans_create_node_ptr_type(c, child_qt.isConstQualified(),
-                            child_qt.isVolatileQualified(), child_node, PtrLenC);
+                    return trans_create_node_ptr_type(c,
+                            ZigClangQualType_isConstQualified(child_qt),
+                            ZigClangQualType_isVolatileQualified(child_qt),
+                            child_node, PtrLenC);
                 }
             }
-        case clang::Type::Typedef:
+        case ZigClangType_Typedef:
             {
-                const clang::TypedefType *typedef_ty = static_cast<const clang::TypedefType*>(ty);
-                const clang::TypedefNameDecl *typedef_decl = typedef_ty->getDecl();
+                const ZigClangTypedefType *typedef_ty = reinterpret_cast<const ZigClangTypedefType*>(ty);
+                const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
                 return resolve_typedef_decl(c, typedef_decl);
             }
-        case clang::Type::Elaborated:
+        case ZigClangType_Elaborated:
             {
-                const clang::ElaboratedType *elaborated_ty = static_cast<const clang::ElaboratedType*>(ty);
+                const clang::ElaboratedType *elaborated_ty = reinterpret_cast<const clang::ElaboratedType*>(ty);
                 switch (elaborated_ty->getKeyword()) {
                     case clang::ETK_Struct:
                     case clang::ETK_Enum:
                     case clang::ETK_Union:
-                        return trans_qual_type(c, elaborated_ty->getNamedType(), source_loc);
+                        return trans_qual_type(c, bitcast(elaborated_ty->getNamedType()), source_loc);
                     case clang::ETK_Interface:
                     case clang::ETK_Class:
                     case clang::ETK_Typename:
@@ -1004,81 +1058,81 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, const clang::Sourc
                         return nullptr;
                 }
             }
-        case clang::Type::FunctionProto:
-        case clang::Type::FunctionNoProto:
+        case ZigClangType_FunctionProto:
+        case ZigClangType_FunctionNoProto:
             {
-                const clang::FunctionType *fn_ty = static_cast<const clang::FunctionType*>(ty);
+                const ZigClangFunctionType *fn_ty = reinterpret_cast<const ZigClangFunctionType*>(ty);
 
                 AstNode *proto_node = trans_create_node(c, NodeTypeFnProto);
-                switch (fn_ty->getCallConv()) {
-                    case clang::CC_C:           // __attribute__((cdecl))
+                switch (ZigClangFunctionType_getCallConv(fn_ty)) {
+                    case ZigClangCallingConv_C:           // __attribute__((cdecl))
                         proto_node->data.fn_proto.cc = CallingConventionC;
                         proto_node->data.fn_proto.is_extern = true;
                         break;
-                    case clang::CC_X86StdCall:  // __attribute__((stdcall))
+                    case ZigClangCallingConv_X86StdCall:  // __attribute__((stdcall))
                         proto_node->data.fn_proto.cc = CallingConventionStdcall;
                         break;
-                    case clang::CC_X86FastCall: // __attribute__((fastcall))
+                    case ZigClangCallingConv_X86FastCall: // __attribute__((fastcall))
                         emit_warning(c, source_loc, "unsupported calling convention: x86 fastcall");
                         return nullptr;
-                    case clang::CC_X86ThisCall: // __attribute__((thiscall))
+                    case ZigClangCallingConv_X86ThisCall: // __attribute__((thiscall))
                         emit_warning(c, source_loc, "unsupported calling convention: x86 thiscall");
                         return nullptr;
-                    case clang::CC_X86VectorCall: // __attribute__((vectorcall))
+                    case ZigClangCallingConv_X86VectorCall: // __attribute__((vectorcall))
                         emit_warning(c, source_loc, "unsupported calling convention: x86 vectorcall");
                         return nullptr;
-                    case clang::CC_X86Pascal:   // __attribute__((pascal))
+                    case ZigClangCallingConv_X86Pascal:   // __attribute__((pascal))
                         emit_warning(c, source_loc, "unsupported calling convention: x86 pascal");
                         return nullptr;
-                    case clang::CC_Win64: // __attribute__((ms_abi))
+                    case ZigClangCallingConv_Win64: // __attribute__((ms_abi))
                         emit_warning(c, source_loc, "unsupported calling convention: win64");
                         return nullptr;
-                    case clang::CC_X86_64SysV:  // __attribute__((sysv_abi))
+                    case ZigClangCallingConv_X86_64SysV:  // __attribute__((sysv_abi))
                         emit_warning(c, source_loc, "unsupported calling convention: x86 64sysv");
                         return nullptr;
-                    case clang::CC_X86RegCall:
+                    case ZigClangCallingConv_X86RegCall:
                         emit_warning(c, source_loc, "unsupported calling convention: x86 reg");
                         return nullptr;
-                    case clang::CC_AAPCS:       // __attribute__((pcs("aapcs")))
+                    case ZigClangCallingConv_AAPCS:       // __attribute__((pcs("aapcs")))
                         emit_warning(c, source_loc, "unsupported calling convention: aapcs");
                         return nullptr;
-                    case clang::CC_AAPCS_VFP:   // __attribute__((pcs("aapcs-vfp")))
+                    case ZigClangCallingConv_AAPCS_VFP:   // __attribute__((pcs("aapcs-vfp")))
                         emit_warning(c, source_loc, "unsupported calling convention: aapcs-vfp");
                         return nullptr;
-                    case clang::CC_IntelOclBicc: // __attribute__((intel_ocl_bicc))
+                    case ZigClangCallingConv_IntelOclBicc: // __attribute__((intel_ocl_bicc))
                         emit_warning(c, source_loc, "unsupported calling convention: intel_ocl_bicc");
                         return nullptr;
-                    case clang::CC_SpirFunction: // default for OpenCL functions on SPIR target
+                    case ZigClangCallingConv_SpirFunction: // default for OpenCL functions on SPIR target
                         emit_warning(c, source_loc, "unsupported calling convention: SPIR function");
                         return nullptr;
-                    case clang::CC_OpenCLKernel:
+                    case ZigClangCallingConv_OpenCLKernel:
                         emit_warning(c, source_loc, "unsupported calling convention: OpenCLKernel");
                         return nullptr;
-                    case clang::CC_Swift:
+                    case ZigClangCallingConv_Swift:
                         emit_warning(c, source_loc, "unsupported calling convention: Swift");
                         return nullptr;
-                    case clang::CC_PreserveMost:
+                    case ZigClangCallingConv_PreserveMost:
                         emit_warning(c, source_loc, "unsupported calling convention: PreserveMost");
                         return nullptr;
-                    case clang::CC_PreserveAll:
+                    case ZigClangCallingConv_PreserveAll:
                         emit_warning(c, source_loc, "unsupported calling convention: PreserveAll");
                         return nullptr;
-                    case clang::CC_AArch64VectorCall:
+                    case ZigClangCallingConv_AArch64VectorCall:
                         emit_warning(c, source_loc, "unsupported calling convention: AArch64VectorCall");
                         return nullptr;
                 }
 
-                if (fn_ty->getNoReturnAttr()) {
+                if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) {
                     proto_node->data.fn_proto.return_type = trans_create_node_symbol_str(c, "noreturn");
                 } else {
-                    proto_node->data.fn_proto.return_type = trans_qual_type(c, fn_ty->getReturnType(),
-                            source_loc);
+                    proto_node->data.fn_proto.return_type = trans_qual_type(c,
+                            ZigClangFunctionType_getReturnType(fn_ty), source_loc);
                     if (proto_node->data.fn_proto.return_type == nullptr) {
                         emit_warning(c, source_loc, "unsupported function proto return type");
                         return nullptr;
                     }
                     // convert c_void to actual void (only for return type)
-                    // we do want to look at the AstNode instead of clang::QualType, because
+                    // we do want to look at the AstNode instead of ZigClangQualType, because
                     // if they do something like:
                     //     typedef Foo void;
                     //     void foo(void) -> Foo;
@@ -1094,17 +1148,17 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, const clang::Sourc
                     proto_node->data.fn_proto.name = buf_create_from_str(fn_name);
                 }
 
-                if (ty->getTypeClass() == clang::Type::FunctionNoProto) {
+                if (ZigClangType_getTypeClass(ty) == ZigClangType_FunctionNoProto) {
                     return proto_node;
                 }
 
-                const clang::FunctionProtoType *fn_proto_ty = static_cast<const clang::FunctionProtoType*>(ty);
+                const ZigClangFunctionProtoType *fn_proto_ty = reinterpret_cast<const ZigClangFunctionProtoType*>(ty);
 
-                proto_node->data.fn_proto.is_var_args = fn_proto_ty->isVariadic();
-                size_t param_count = fn_proto_ty->getNumParams();
+                proto_node->data.fn_proto.is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty);
+                size_t param_count = ZigClangFunctionProtoType_getNumParams(fn_proto_ty);
 
                 for (size_t i = 0; i < param_count; i += 1) {
-                    clang::QualType qt = fn_proto_ty->getParamType(i);
+                    ZigClangQualType qt = ZigClangFunctionProtoType_getParamType(fn_proto_ty, i);
                     AstNode *param_type_node = trans_qual_type(c, qt, source_loc);
 
                     if (param_type_node == nullptr) {
@@ -1118,7 +1172,7 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, const clang::Sourc
                     if (param_name != nullptr) {
                         param_node->data.param_decl.name = buf_create_from_str(param_name);
                     }
-                    param_node->data.param_decl.is_noalias = qt.isRestrictQualified();
+                    param_node->data.param_decl.is_noalias = ZigClangQualType_isRestrictQualified(qt);
                     param_node->data.param_decl.type = param_type_node;
                     proto_node->data.fn_proto.params.append(param_node);
                 }
@@ -1127,20 +1181,20 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, const clang::Sourc
 
                 return proto_node;
             }
-        case clang::Type::Record:
+        case ZigClangType_Record:
             {
-                const clang::RecordType *record_ty = static_cast<const clang::RecordType*>(ty);
-                return resolve_record_decl(c, record_ty->getDecl());
+                const ZigClangRecordType *record_ty = reinterpret_cast<const ZigClangRecordType*>(ty);
+                return resolve_record_decl(c, ZigClangRecordType_getDecl(record_ty));
             }
-        case clang::Type::Enum:
+        case ZigClangType_Enum:
             {
-                const clang::EnumType *enum_ty = static_cast<const clang::EnumType*>(ty);
-                return resolve_enum_decl(c, enum_ty->getDecl());
+                const ZigClangEnumType *enum_ty = reinterpret_cast<const ZigClangEnumType*>(ty);
+                return resolve_enum_decl(c, ZigClangEnumType_getDecl(enum_ty));
             }
-        case clang::Type::ConstantArray:
+        case ZigClangType_ConstantArray:
             {
-                const clang::ConstantArrayType *const_arr_ty = static_cast<const clang::ConstantArrayType *>(ty);
-                AstNode *child_type_node = trans_qual_type(c, const_arr_ty->getElementType(), source_loc);
+                const clang::ConstantArrayType *const_arr_ty = reinterpret_cast<const clang::ConstantArrayType *>(ty);
+                AstNode *child_type_node = trans_qual_type(c, bitcast(const_arr_ty->getElementType()), source_loc);
                 if (child_type_node == nullptr) {
                     emit_warning(c, source_loc, "unresolved array element type");
                     return nullptr;
@@ -1149,83 +1203,87 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, const clang::Sourc
                 AstNode *size_node = trans_create_node_unsigned(c, size);
                 return trans_create_node_array_type(c, size_node, child_type_node);
             }
-        case clang::Type::Paren:
+        case ZigClangType_Paren:
             {
-                const clang::ParenType *paren_ty = static_cast<const clang::ParenType *>(ty);
-                return trans_qual_type(c, paren_ty->getInnerType(), source_loc);
+                const clang::ParenType *paren_ty = reinterpret_cast<const clang::ParenType *>(ty);
+                return trans_qual_type(c, bitcast(paren_ty->getInnerType()), source_loc);
             }
-        case clang::Type::Decayed:
+        case ZigClangType_Decayed:
             {
-                const clang::DecayedType *decayed_ty = static_cast<const clang::DecayedType *>(ty);
-                return trans_qual_type(c, decayed_ty->getDecayedType(), source_loc);
+                const clang::DecayedType *decayed_ty = reinterpret_cast<const clang::DecayedType *>(ty);
+                return trans_qual_type(c, bitcast(decayed_ty->getDecayedType()), source_loc);
             }
-        case clang::Type::Attributed:
+        case ZigClangType_Attributed:
             {
-                const clang::AttributedType *attributed_ty = static_cast<const clang::AttributedType *>(ty);
-                return trans_qual_type(c, attributed_ty->getEquivalentType(), source_loc);
+                const clang::AttributedType *attributed_ty = reinterpret_cast<const clang::AttributedType *>(ty);
+                return trans_qual_type(c, bitcast(attributed_ty->getEquivalentType()), source_loc);
             }
-        case clang::Type::IncompleteArray:
+        case ZigClangType_IncompleteArray:
             {
-                const clang::IncompleteArrayType *incomplete_array_ty = static_cast<const clang::IncompleteArrayType *>(ty);
-                clang::QualType child_qt = incomplete_array_ty->getElementType();
+                const clang::IncompleteArrayType *incomplete_array_ty = reinterpret_cast<const clang::IncompleteArrayType *>(ty);
+                ZigClangQualType child_qt = bitcast(incomplete_array_ty->getElementType());
                 AstNode *child_type_node = trans_qual_type(c, child_qt, source_loc);
                 if (child_type_node == nullptr) {
                     emit_warning(c, source_loc, "unresolved array element type");
                     return nullptr;
                 }
-                AstNode *pointer_node = trans_create_node_ptr_type(c, child_qt.isConstQualified(),
-                        child_qt.isVolatileQualified(), child_type_node, PtrLenC);
+                AstNode *pointer_node = trans_create_node_ptr_type(c,
+                        ZigClangQualType_isConstQualified(child_qt),
+                        ZigClangQualType_isVolatileQualified(child_qt),
+                        child_type_node, PtrLenC);
                 return pointer_node;
             }
-        case clang::Type::BlockPointer:
-        case clang::Type::LValueReference:
-        case clang::Type::RValueReference:
-        case clang::Type::MemberPointer:
-        case clang::Type::VariableArray:
-        case clang::Type::DependentSizedArray:
-        case clang::Type::DependentSizedExtVector:
-        case clang::Type::Vector:
-        case clang::Type::ExtVector:
-        case clang::Type::UnresolvedUsing:
-        case clang::Type::Adjusted:
-        case clang::Type::TypeOfExpr:
-        case clang::Type::TypeOf:
-        case clang::Type::Decltype:
-        case clang::Type::UnaryTransform:
-        case clang::Type::TemplateTypeParm:
-        case clang::Type::SubstTemplateTypeParm:
-        case clang::Type::SubstTemplateTypeParmPack:
-        case clang::Type::TemplateSpecialization:
-        case clang::Type::Auto:
-        case clang::Type::InjectedClassName:
-        case clang::Type::DependentName:
-        case clang::Type::DependentTemplateSpecialization:
-        case clang::Type::PackExpansion:
-        case clang::Type::ObjCObject:
-        case clang::Type::ObjCInterface:
-        case clang::Type::Complex:
-        case clang::Type::ObjCObjectPointer:
-        case clang::Type::Atomic:
-        case clang::Type::Pipe:
-        case clang::Type::ObjCTypeParam:
-        case clang::Type::DeducedTemplateSpecialization:
-        case clang::Type::DependentAddressSpace:
-        case clang::Type::DependentVector:
-            emit_warning(c, source_loc, "unsupported type: '%s'", ty->getTypeClassName());
+        case ZigClangType_BlockPointer:
+        case ZigClangType_LValueReference:
+        case ZigClangType_RValueReference:
+        case ZigClangType_MemberPointer:
+        case ZigClangType_VariableArray:
+        case ZigClangType_DependentSizedArray:
+        case ZigClangType_DependentSizedExtVector:
+        case ZigClangType_Vector:
+        case ZigClangType_ExtVector:
+        case ZigClangType_UnresolvedUsing:
+        case ZigClangType_Adjusted:
+        case ZigClangType_TypeOfExpr:
+        case ZigClangType_TypeOf:
+        case ZigClangType_Decltype:
+        case ZigClangType_UnaryTransform:
+        case ZigClangType_TemplateTypeParm:
+        case ZigClangType_SubstTemplateTypeParm:
+        case ZigClangType_SubstTemplateTypeParmPack:
+        case ZigClangType_TemplateSpecialization:
+        case ZigClangType_Auto:
+        case ZigClangType_InjectedClassName:
+        case ZigClangType_DependentName:
+        case ZigClangType_DependentTemplateSpecialization:
+        case ZigClangType_PackExpansion:
+        case ZigClangType_ObjCObject:
+        case ZigClangType_ObjCInterface:
+        case ZigClangType_Complex:
+        case ZigClangType_ObjCObjectPointer:
+        case ZigClangType_Atomic:
+        case ZigClangType_Pipe:
+        case ZigClangType_ObjCTypeParam:
+        case ZigClangType_DeducedTemplateSpecialization:
+        case ZigClangType_DependentAddressSpace:
+        case ZigClangType_DependentVector:
+            emit_warning(c, source_loc, "unsupported type: '%s'", ZigClangType_getTypeClassName(ty));
             return nullptr;
     }
     zig_unreachable();
 }
 
-static AstNode *trans_qual_type(Context *c, clang::QualType qt, const clang::SourceLocation &source_loc) {
-    return trans_type(c, qt.getTypePtr(), source_loc);
+static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc) {
+    return trans_type(c, ZigClangQualType_getTypePtr(qt), source_loc);
 }
 
-static int trans_compound_stmt_inline(Context *c, TransScope *scope, const clang::CompoundStmt *stmt,
+static int trans_compound_stmt_inline(Context *c, TransScope *scope, const ZigClangCompoundStmt *stmt,
         AstNode *block_node, TransScope **out_node_scope)
 {
     assert(block_node->type == NodeTypeBlock);
-    for (clang::CompoundStmt::const_body_iterator it = stmt->body_begin(), end_it = stmt->body_end(); it != end_it; ++it) {
+    for (ZigClangCompoundStmt_const_body_iterator it = ZigClangCompoundStmt_body_begin(stmt),
+        end_it = ZigClangCompoundStmt_body_end(stmt); it != end_it; ++it)
+    {
         AstNode *child_node;
         scope = trans_stmt(c, scope, *it, &child_node);
         if (scope == nullptr)
@@ -1239,7 +1297,7 @@ static int trans_compound_stmt_inline(Context *c, TransScope *scope, const clang
     return ErrorNone;
 }
 
-static AstNode *trans_compound_stmt(Context *c, TransScope *scope, const clang::CompoundStmt *stmt,
+static AstNode *trans_compound_stmt(Context *c, TransScope *scope, const ZigClangCompoundStmt *stmt,
         TransScope **out_node_scope)
 {
     TransScopeBlock *child_scope_block = trans_scope_block_create(c, scope);
@@ -1251,7 +1309,7 @@ static AstNode *trans_compound_stmt(Context *c, TransScope *scope, const clang::
 static AstNode *trans_stmt_expr(Context *c, ResultUsed result_used, TransScope *scope,
         const clang::StmtExpr *stmt, TransScope **out_node_scope)
 {
-    AstNode *block = trans_compound_stmt(c, scope, stmt->getSubStmt(), out_node_scope);
+    AstNode *block = trans_compound_stmt(c, scope, (const ZigClangCompoundStmt *)stmt->getSubStmt(), out_node_scope);
     if (block == nullptr)
         return block;
     assert(block->type == NodeTypeBlock);
@@ -1274,7 +1332,7 @@ static AstNode *trans_stmt_expr(Context *c, ResultUsed result_used, TransScope *
 }
 
 static AstNode *trans_return_stmt(Context *c, TransScope *scope, const clang::ReturnStmt *stmt) {
-    const clang::Expr *value_expr = stmt->getRetValue();
+    const ZigClangExpr *value_expr = bitcast(stmt->getRetValue());
     if (value_expr == nullptr) {
         return trans_create_node(c, NodeTypeReturnExpr);
     } else {
@@ -1289,22 +1347,62 @@ static AstNode *trans_return_stmt(Context *c, TransScope *scope, const clang::Re
 static AstNode *trans_integer_literal(Context *c, ResultUsed result_used, const clang::IntegerLiteral *stmt) {
     clang::Expr::EvalResult result;
     if (!stmt->EvaluateAsInt(result, *reinterpret_cast<clang::ASTContext *>(c->ctx))) {
-        emit_warning(c, stmt->getBeginLoc(), "invalid integer literal");
+        emit_warning(c, bitcast(stmt->getBeginLoc()), "invalid integer literal");
+        return nullptr;
+    }
+    AstNode *node = trans_create_node_apint(c, bitcast(&result.Val.getInt()));
+    return maybe_suppress_result(c, result_used, node);
+}
+
+static AstNode *trans_floating_literal(Context *c, ResultUsed result_used, const clang::FloatingLiteral *stmt) {
+    llvm::APFloat result{0.0f};
+    if (!stmt->EvaluateAsFloat(result, *reinterpret_cast<clang::ASTContext *>(c->ctx))) {
+        emit_warning(c, bitcast(stmt->getBeginLoc()), "invalid floating literal");
         return nullptr;
     }
-    AstNode *node = trans_create_node_apint(c, result.Val.getInt());
+    AstNode *node = trans_create_node_apfloat(c, result);
     return maybe_suppress_result(c, result_used, node);
 }
 
+static AstNode *trans_character_literal(Context *c, ResultUsed result_used, const clang::CharacterLiteral *stmt) {
+    switch (stmt->getKind()) {
+        case clang::CharacterLiteral::CharacterKind::Ascii:
+            {
+                unsigned val = stmt->getValue();
+                // C has a somewhat obscure feature called multi-character character
+                // constant
+                if (val > 255)
+                    return trans_create_node_unsigned(c, val);
+            }
+            // fallthrough
+        case clang::CharacterLiteral::CharacterKind::UTF8:
+            {
+                AstNode *node = trans_create_node(c, NodeTypeCharLiteral);
+                node->data.char_literal.value = stmt->getValue();
+                return maybe_suppress_result(c, result_used, node);
+            }
+        case clang::CharacterLiteral::CharacterKind::UTF16:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO support UTF16 character literals");
+            return nullptr;
+        case clang::CharacterLiteral::CharacterKind::UTF32:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO support UTF32 character literals");
+            return nullptr;
+        case clang::CharacterLiteral::CharacterKind::Wide:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO support wide character literals");
+            return nullptr;
+    }
+    zig_unreachable();
+}
+
 static AstNode *trans_constant_expr(Context *c, ResultUsed result_used, const clang::ConstantExpr *expr) {
     clang::Expr::EvalResult result;
     if (!expr->EvaluateAsConstantExpr(result, clang::Expr::EvaluateForCodeGen,
                 *reinterpret_cast<clang::ASTContext *>(c->ctx)))
     {
-        emit_warning(c, expr->getBeginLoc(), "invalid constant expression");
+        emit_warning(c, bitcast(expr->getBeginLoc()), "invalid constant expression");
         return nullptr;
     }
-    AstNode *node = trans_ap_value(c, &result.Val, expr->getType(), expr->getBeginLoc());
+    AstNode *node = trans_ap_value(c, bitcast(&result.Val), bitcast(expr->getType()), bitcast(expr->getBeginLoc()));
     return maybe_suppress_result(c, result_used, node);
 }
 
@@ -1313,9 +1411,9 @@ static AstNode *trans_conditional_operator(Context *c, ResultUsed result_used, T
 {
     AstNode *node = trans_create_node(c, NodeTypeIfBoolExpr);
 
-    clang::Expr *cond_expr = stmt->getCond();
-    clang::Expr *true_expr = stmt->getTrueExpr();
-    clang::Expr *false_expr = stmt->getFalseExpr();
+    const ZigClangExpr *cond_expr = bitcast(stmt->getCond());
+    const ZigClangExpr *true_expr = bitcast(stmt->getTrueExpr());
+    const ZigClangExpr *false_expr = bitcast(stmt->getFalseExpr());
 
     node->data.if_bool_expr.condition = trans_expr(c, ResultUsedYes, scope, cond_expr, TransRValue);
     if (node->data.if_bool_expr.condition == nullptr)
@@ -1332,7 +1430,9 @@ static AstNode *trans_conditional_operator(Context *c, ResultUsed result_used, T
     return maybe_suppress_result(c, result_used, node);
 }
 
-static AstNode *trans_create_bin_op(Context *c, TransScope *scope, clang::Expr *lhs, BinOpType bin_op, clang::Expr *rhs) {
+static AstNode *trans_create_bin_op(Context *c, TransScope *scope, const ZigClangExpr *lhs,
+        BinOpType bin_op, const ZigClangExpr *rhs)
+{
     AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
     node->data.bin_op_expr.bin_op = bin_op;
 
@@ -1347,7 +1447,9 @@ static AstNode *trans_create_bin_op(Context *c, TransScope *scope, clang::Expr *
     return node;
 }
 
-static AstNode *trans_create_bool_bin_op(Context *c, TransScope *scope, clang::Expr *lhs, BinOpType bin_op, clang::Expr *rhs) {
+static AstNode *trans_create_bool_bin_op(Context *c, TransScope *scope, const ZigClangExpr *lhs,
+        BinOpType bin_op, const ZigClangExpr *rhs)
+{
     assert(bin_op == BinOpTypeBoolAnd || bin_op == BinOpTypeBoolOr);
     AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
     node->data.bin_op_expr.bin_op = bin_op;
@@ -1363,7 +1465,9 @@ static AstNode *trans_create_bool_bin_op(Context *c, TransScope *scope, clang::E
     return node;
 }
 
-static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransScope *scope, clang::Expr *lhs, clang::Expr *rhs) {
+static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransScope *scope,
+        const ZigClangExpr *lhs, const ZigClangExpr *rhs)
+{
     if (result_used == ResultUsedNo) {
         // common case
         AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
@@ -1414,10 +1518,10 @@ static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransSco
     }
 }
 
-static AstNode *trans_create_shift_op(Context *c, TransScope *scope, clang::QualType result_type,
-        clang::Expr *lhs_expr, BinOpType bin_op, clang::Expr *rhs_expr)
+static AstNode *trans_create_shift_op(Context *c, TransScope *scope, ZigClangQualType result_type,
+        const ZigClangExpr *lhs_expr, BinOpType bin_op, const ZigClangExpr *rhs_expr)
 {
-    const clang::SourceLocation &rhs_location = rhs_expr->getBeginLoc();
+    ZigClangSourceLocation rhs_location = ZigClangExpr_getBeginLoc(rhs_expr);
     AstNode *rhs_type = qual_type_to_log2_int_ref(c, result_type, rhs_location);
     // lhs >> u5(rh)
 
@@ -1434,130 +1538,130 @@ static AstNode *trans_create_shift_op(Context *c, TransScope *scope, clang::Qual
 static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransScope *scope, const clang::BinaryOperator *stmt) {
     switch (stmt->getOpcode()) {
         case clang::BO_PtrMemD:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle more C binary operators: BO_PtrMemD");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C binary operators: BO_PtrMemD");
             return nullptr;
         case clang::BO_PtrMemI:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle more C binary operators: BO_PtrMemI");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C binary operators: BO_PtrMemI");
             return nullptr;
         case clang::BO_Cmp:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle more C binary operators: BO_Cmp");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C binary operators: BO_Cmp");
             return nullptr;
         case clang::BO_Mul: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
-                qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeMultWrap : BinOpTypeMult,
-                stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()),
+                qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeMultWrap : BinOpTypeMult,
+                bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_Div:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType())) {
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) {
                 // unsigned/float division uses the operator
-                AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeDiv, stmt->getRHS());
+                AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeDiv, bitcast(stmt->getRHS()));
                 return maybe_suppress_result(c, result_used, node);
             } else {
                 // signed integer division uses @divTrunc
                 AstNode *fn_call = trans_create_node_builtin_fn_call_str(c, "divTrunc");
-                AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue);
+                AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue);
                 if (lhs == nullptr) return nullptr;
                 fn_call->data.fn_call_expr.params.append(lhs);
-                AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransLValue);
+                AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransLValue);
                 if (rhs == nullptr) return nullptr;
                 fn_call->data.fn_call_expr.params.append(rhs);
                 return maybe_suppress_result(c, result_used, fn_call);
             }
         case clang::BO_Rem:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType())) {
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) {
                 // unsigned/float division uses the operator
-                AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeMod, stmt->getRHS());
+                AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeMod, bitcast(stmt->getRHS()));
                 return maybe_suppress_result(c, result_used, node);
             } else {
                 // signed integer division uses @rem
                 AstNode *fn_call = trans_create_node_builtin_fn_call_str(c, "rem");
-                AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue);
+                AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue);
                 if (lhs == nullptr) return nullptr;
                 fn_call->data.fn_call_expr.params.append(lhs);
-                AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransLValue);
+                AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransLValue);
                 if (rhs == nullptr) return nullptr;
                 fn_call->data.fn_call_expr.params.append(rhs);
                 return maybe_suppress_result(c, result_used, fn_call);
             }
         case clang::BO_Add: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
-                qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeAddWrap : BinOpTypeAdd,
-                stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()),
+                qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeAddWrap : BinOpTypeAdd,
+                bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_Sub: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
-                qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeSubWrap : BinOpTypeSub,
-                stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()),
+                qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeSubWrap : BinOpTypeSub,
+                bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_Shl: {
-            AstNode *node = trans_create_shift_op(c, scope, stmt->getType(), stmt->getLHS(), BinOpTypeBitShiftLeft, stmt->getRHS());
+            AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), bitcast(stmt->getLHS()), BinOpTypeBitShiftLeft, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_Shr: {
-            AstNode *node = trans_create_shift_op(c, scope, stmt->getType(), stmt->getLHS(), BinOpTypeBitShiftRight, stmt->getRHS());
+            AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), bitcast(stmt->getLHS()), BinOpTypeBitShiftRight, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_LT: {
-            AstNode *node =trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpLessThan, stmt->getRHS());
+            AstNode *node =trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpLessThan, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_GT: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpGreaterThan, stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpGreaterThan, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_LE: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpLessOrEq, stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpLessOrEq, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_GE: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpGreaterOrEq, stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpGreaterOrEq, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_EQ: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpEq, stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpEq, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_NE: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpNotEq, stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpNotEq, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_And: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinAnd, stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinAnd, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_Xor: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinXor, stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinXor, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_Or: {
-            AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinOr, stmt->getRHS());
+            AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinOr, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_LAnd: {
-            AstNode *node = trans_create_bool_bin_op(c, scope, stmt->getLHS(), BinOpTypeBoolAnd, stmt->getRHS());
+            AstNode *node = trans_create_bool_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBoolAnd, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_LOr: {
-            AstNode *node = trans_create_bool_bin_op(c, scope, stmt->getLHS(), BinOpTypeBoolOr, stmt->getRHS());
+            AstNode *node = trans_create_bool_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBoolOr, bitcast(stmt->getRHS()));
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::BO_Assign:
-            return trans_create_assign(c, result_used, scope, stmt->getLHS(), stmt->getRHS());
+            return trans_create_assign(c, result_used, scope, bitcast(stmt->getLHS()), bitcast(stmt->getRHS()));
         case clang::BO_Comma:
             {
                 TransScopeBlock *scope_block = trans_scope_block_create(c, scope);
                 Buf *label_name = buf_create_from_str("x");
                 scope_block->node->data.block.name = label_name;
 
-                AstNode *lhs = trans_expr(c, ResultUsedNo, &scope_block->base, stmt->getLHS(), TransRValue);
+                AstNode *lhs = trans_expr(c, ResultUsedNo, &scope_block->base, bitcast(stmt->getLHS()), TransRValue);
                 if (lhs == nullptr)
                     return nullptr;
                 scope_block->node->data.block.statements.append(lhs);
 
-                AstNode *rhs = trans_expr(c, ResultUsedYes, &scope_block->base, stmt->getRHS(), TransRValue);
+                AstNode *rhs = trans_expr(c, ResultUsedYes, &scope_block->base, bitcast(stmt->getRHS()), TransRValue);
                 if (rhs == nullptr)
                     return nullptr;
 
@@ -1584,17 +1688,17 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS
 static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result_used, TransScope *scope,
         const clang::CompoundAssignOperator *stmt, BinOpType assign_op, BinOpType bin_op)
 {
-    const clang::SourceLocation &rhs_location = stmt->getRHS()->getBeginLoc();
-    AstNode *rhs_type = qual_type_to_log2_int_ref(c, stmt->getComputationLHSType(), rhs_location);
+    ZigClangSourceLocation rhs_location = bitcast(stmt->getRHS()->getBeginLoc());
+    AstNode *rhs_type = qual_type_to_log2_int_ref(c, bitcast(stmt->getComputationLHSType()), rhs_location);
 
     bool use_intermediate_casts = stmt->getComputationLHSType().getTypePtr() != stmt->getComputationResultType().getTypePtr();
     if (!use_intermediate_casts && result_used == ResultUsedNo) {
         // simple common case, where the C and Zig are identical:
         // lhs >>= rhs
-        AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue);
+        AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue);
         if (lhs == nullptr) return nullptr;
 
-        AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransRValue);
+        AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransRValue);
         if (rhs == nullptr) return nullptr;
         AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs);
 
@@ -1614,7 +1718,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
         child_scope->node->data.block.name = label_name;
 
         // const _ref = &lhs;
-        AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getLHS(), TransLValue);
+        AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getLHS()), TransLValue);
         if (lhs == nullptr) return nullptr;
         AstNode *addr_of_lhs = trans_create_node_addr_of(c, lhs);
         // TODO: avoid name collisions with generated variable names
@@ -1624,20 +1728,20 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
 
         // *_ref = result_type(operation_type(*_ref) >> u5(rhs));
 
-        AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getRHS(), TransRValue);
+        AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getRHS()), TransRValue);
         if (rhs == nullptr) return nullptr;
         AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs);
 
         // operation_type(*_ref)
         AstNode *operation_type_cast = trans_c_cast(c, rhs_location,
-            stmt->getComputationLHSType(),
-            stmt->getLHS()->getType(),
+            bitcast(stmt->getComputationLHSType()),
+            bitcast(stmt->getLHS()->getType()),
             trans_create_node_ptr_deref(c, trans_create_node_symbol(c, tmp_var_name)));
 
         // result_type(... >> u5(rhs))
         AstNode *result_type_cast = trans_c_cast(c, rhs_location,
-            stmt->getComputationResultType(),
-            stmt->getComputationLHSType(),
+            bitcast(stmt->getComputationResultType()),
+            bitcast(stmt->getComputationLHSType()),
             trans_create_node_bin_op(c,
                 operation_type_cast,
                 bin_op,
@@ -1669,9 +1773,9 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used,
     if (result_used == ResultUsedNo) {
         // simple common case, where the C and Zig are identical:
         // lhs += rhs
-        AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue);
+        AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue);
         if (lhs == nullptr) return nullptr;
-        AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransRValue);
+        AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransRValue);
         if (rhs == nullptr) return nullptr;
         return trans_create_node_bin_op(c, lhs, assign_op, rhs);
     } else {
@@ -1688,7 +1792,7 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used,
         child_scope->node->data.block.name = label_name;
 
         // const _ref = &lhs;
-        AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getLHS(), TransLValue);
+        AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getLHS()), TransLValue);
         if (lhs == nullptr) return nullptr;
         AstNode *addr_of_lhs = trans_create_node_addr_of(c, lhs);
         // TODO: avoid name collisions with generated variable names
@@ -1698,7 +1802,7 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used,
 
         // *_ref = *_ref + rhs;
 
-        AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getRHS(), TransRValue);
+        AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getRHS()), TransRValue);
         if (rhs == nullptr) return nullptr;
 
         AstNode *assign_statement = trans_create_node_bin_op(c,
@@ -1728,26 +1832,26 @@ static AstNode *trans_compound_assign_operator(Context *c, ResultUsed result_use
 {
     switch (stmt->getOpcode()) {
         case clang::BO_MulAssign:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType()))
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
                 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignTimesWrap, BinOpTypeMultWrap);
             else
                 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignTimes, BinOpTypeMult);
         case clang::BO_DivAssign:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle more C compound assign operators: BO_DivAssign");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C compound assign operators: BO_DivAssign");
             return nullptr;
         case clang::BO_RemAssign:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle more C compound assign operators: BO_RemAssign");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C compound assign operators: BO_RemAssign");
             return nullptr;
         case clang::BO_Cmp:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle more C compound assign operators: BO_Cmp");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C compound assign operators: BO_Cmp");
             return nullptr;
         case clang::BO_AddAssign:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType()))
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
                 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap, BinOpTypeAddWrap);
             else
                 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignPlus, BinOpTypeAdd);
         case clang::BO_SubAssign:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType()))
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
                 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap, BinOpTypeSubWrap);
             else
                 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignMinus, BinOpTypeSub);
@@ -1790,202 +1894,265 @@ static AstNode *trans_compound_assign_operator(Context *c, ResultUsed result_use
 }
 
 static AstNode *trans_implicit_cast_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::ImplicitCastExpr *stmt) {
-    switch (stmt->getCastKind()) {
-        case clang::CK_LValueToRValue:
-            return trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
-        case clang::CK_IntegralCast:
+    switch ((ZigClangCK)stmt->getCastKind()) {
+        case ZigClangCK_LValueToRValue:
+            return trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
+        case ZigClangCK_IntegralCast:
             {
-                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
+                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
                 if (target_node == nullptr)
                     return nullptr;
-                AstNode *node = trans_c_cast(c, stmt->getExprLoc(), stmt->getType(),
-                        stmt->getSubExpr()->getType(), target_node);
+                AstNode *node = trans_c_cast(c, bitcast(stmt->getExprLoc()), bitcast(stmt->getType()),
+                        bitcast(stmt->getSubExpr()->getType()), target_node);
                 return maybe_suppress_result(c, result_used, node);
             }
-        case clang::CK_FunctionToPointerDecay:
-        case clang::CK_ArrayToPointerDecay:
+        case ZigClangCK_FunctionToPointerDecay:
+        case ZigClangCK_ArrayToPointerDecay:
             {
-                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
+                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
                 if (target_node == nullptr)
                     return nullptr;
                 return maybe_suppress_result(c, result_used, target_node);
             }
-        case clang::CK_BitCast:
+        case ZigClangCK_BitCast:
             {
-                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
+                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
                 if (target_node == nullptr)
                     return nullptr;
 
-                if (expr_types_equal(c, stmt, stmt->getSubExpr())) {
-                    return target_node;
-                }
+                const ZigClangQualType dest_type = get_expr_qual_type(c, bitcast(stmt));
+                const ZigClangQualType src_type = get_expr_qual_type(c, bitcast(stmt->getSubExpr()));
 
-                AstNode *dest_type_node = get_expr_type(c, stmt);
-
-                AstNode *node = trans_create_node_builtin_fn_call_str(c, "ptrCast");
-                node->data.fn_call_expr.params.append(dest_type_node);
-                node->data.fn_call_expr.params.append(target_node);
-                return maybe_suppress_result(c, result_used, node);
+                return trans_c_cast(c, bitcast(stmt->getBeginLoc()), dest_type, src_type, target_node);
             }
-        case clang::CK_NullToPointer:
-            return trans_create_node_unsigned(c, 0);
-        case clang::CK_NoOp:
-            return trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
-        case clang::CK_Dependent:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_Dependent");
-            return nullptr;
-        case clang::CK_LValueBitCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_LValueBitCast");
-            return nullptr;
-        case clang::CK_BaseToDerived:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_BaseToDerived");
-            return nullptr;
-        case clang::CK_DerivedToBase:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_DerivedToBase");
-            return nullptr;
-        case clang::CK_UncheckedDerivedToBase:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_UncheckedDerivedToBase");
+        case ZigClangCK_NullToPointer:
+            return trans_create_node(c, NodeTypeNullLiteral);
+        case ZigClangCK_NoOp:
+            return trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
+        case ZigClangCK_Dependent:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_Dependent");
             return nullptr;
-        case clang::CK_Dynamic:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_Dynamic");
+        case ZigClangCK_LValueBitCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_LValueBitCast");
             return nullptr;
-        case clang::CK_ToUnion:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_ToUnion");
+        case ZigClangCK_BaseToDerived:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_BaseToDerived");
             return nullptr;
-        case clang::CK_NullToMemberPointer:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_NullToMemberPointer");
+        case ZigClangCK_DerivedToBase:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_DerivedToBase");
             return nullptr;
-        case clang::CK_BaseToDerivedMemberPointer:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_BaseToDerivedMemberPointer");
+        case ZigClangCK_UncheckedDerivedToBase:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_UncheckedDerivedToBase");
             return nullptr;
-        case clang::CK_DerivedToBaseMemberPointer:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_DerivedToBaseMemberPointer");
+        case ZigClangCK_Dynamic:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_Dynamic");
             return nullptr;
-        case clang::CK_MemberPointerToBoolean:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_MemberPointerToBoolean");
+        case ZigClangCK_ToUnion:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_ToUnion");
             return nullptr;
-        case clang::CK_ReinterpretMemberPointer:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_ReinterpretMemberPointer");
+        case ZigClangCK_NullToMemberPointer:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_NullToMemberPointer");
             return nullptr;
-        case clang::CK_UserDefinedConversion:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation cast CK_UserDefinedConversion");
+        case ZigClangCK_BaseToDerivedMemberPointer:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_BaseToDerivedMemberPointer");
             return nullptr;
-        case clang::CK_ConstructorConversion:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_ConstructorConversion");
+        case ZigClangCK_DerivedToBaseMemberPointer:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_DerivedToBaseMemberPointer");
             return nullptr;
-        case clang::CK_IntegralToPointer:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntegralToPointer");
+        case ZigClangCK_MemberPointerToBoolean:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_MemberPointerToBoolean");
             return nullptr;
-        case clang::CK_PointerToIntegral:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_PointerToIntegral");
+        case ZigClangCK_ReinterpretMemberPointer:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_ReinterpretMemberPointer");
             return nullptr;
-        case clang::CK_PointerToBoolean:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_PointerToBoolean");
+        case ZigClangCK_UserDefinedConversion:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_UserDefinedConversion");
             return nullptr;
-        case clang::CK_ToVoid:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_ToVoid");
+        case ZigClangCK_ConstructorConversion:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ConstructorConversion");
             return nullptr;
-        case clang::CK_VectorSplat:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_VectorSplat");
-            return nullptr;
-        case clang::CK_IntegralToBoolean:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntegralToBoolean");
-            return nullptr;
-        case clang::CK_IntegralToFloating:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntegralToFloating");
+        case ZigClangCK_PointerToBoolean:
+            {
+                const clang::Expr *expr = stmt->getSubExpr();
+                AstNode *val = trans_expr(c, ResultUsedYes, scope, bitcast(expr), TransRValue);
+                if (val == nullptr)
+                    return nullptr;
+
+                AstNode *val_ptr = trans_create_node_builtin_fn_call_str(c, "ptrToInt");
+                val_ptr->data.fn_call_expr.params.append(val);
+
+                AstNode *zero = trans_create_node_unsigned(c, 0);
+
+                // Translate as @ptrToInt((&val) != 0)
+                return trans_create_node_bin_op(c, val_ptr, BinOpTypeCmpNotEq, zero);
+            }
+        case ZigClangCK_ToVoid:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ToVoid");
             return nullptr;
-        case clang::CK_FixedPointCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FixedPointCast");
+        case ZigClangCK_VectorSplat:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_VectorSplat");
             return nullptr;
-        case clang::CK_FixedPointToBoolean:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FixedPointToBoolean");
+        case ZigClangCK_IntegralToBoolean:
+            {
+                const clang::Expr *expr = stmt->getSubExpr();
+
+                bool expr_val;
+                if (expr->EvaluateAsBooleanCondition(expr_val, *reinterpret_cast<clang::ASTContext *>(c->ctx))) {
+                    return trans_create_node_bool(c, expr_val);
+                }
+
+                AstNode *val = trans_expr(c, ResultUsedYes, scope, bitcast(expr), TransRValue);
+                if (val == nullptr)
+                    return nullptr;
+
+                AstNode *zero = trans_create_node_unsigned(c, 0);
+
+                // Translate as val != 0
+                return trans_create_node_bin_op(c, val, BinOpTypeCmpNotEq, zero);
+            }
+        case ZigClangCK_PointerToIntegral:
+            {
+                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
+                if (target_node == nullptr)
+                    return nullptr;
+
+                AstNode *dest_type_node = get_expr_type(c, (const ZigClangExpr *)stmt);
+                if (dest_type_node == nullptr)
+                    return nullptr;
+
+                AstNode *val_node = trans_create_node_builtin_fn_call_str(c, "ptrToInt");
+                val_node->data.fn_call_expr.params.append(target_node);
+                // @ptrToInt always returns a usize
+                AstNode *node = trans_create_node_builtin_fn_call_str(c, "intCast");
+                node->data.fn_call_expr.params.append(dest_type_node);
+                node->data.fn_call_expr.params.append(val_node);
+
+                return maybe_suppress_result(c, result_used, node);
+            }
+        case ZigClangCK_IntegralToPointer:
+            {
+                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
+                if (target_node == nullptr)
+                    return nullptr;
+
+                AstNode *dest_type_node = get_expr_type(c, (const ZigClangExpr *)stmt);
+                if (dest_type_node == nullptr)
+                    return nullptr;
+
+                AstNode *node = trans_create_node_builtin_fn_call_str(c, "intToPtr");
+                node->data.fn_call_expr.params.append(dest_type_node);
+                node->data.fn_call_expr.params.append(target_node);
+
+                return maybe_suppress_result(c, result_used, node);
+            }
+        case ZigClangCK_IntegralToFloating:
+        case ZigClangCK_FloatingToIntegral:
+            {
+                AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
+                if (target_node == nullptr)
+                    return nullptr;
+
+                AstNode *dest_type_node = get_expr_type(c, (const ZigClangExpr *)stmt);
+                if (dest_type_node == nullptr)
+                    return nullptr;
+
+                char const *fn = (ZigClangCK)stmt->getCastKind() == ZigClangCK_IntegralToFloating ?
+                    "intToFloat" : "floatToInt";
+                AstNode *node = trans_create_node_builtin_fn_call_str(c, fn);
+                node->data.fn_call_expr.params.append(dest_type_node);
+                node->data.fn_call_expr.params.append(target_node);
+
+                return maybe_suppress_result(c, result_used, node);
+            }
+        case ZigClangCK_FixedPointCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FixedPointCast");
             return nullptr;
-        case clang::CK_FloatingToIntegral:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FloatingToIntegral");
+        case ZigClangCK_FixedPointToBoolean:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FixedPointToBoolean");
             return nullptr;
-        case clang::CK_FloatingToBoolean:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FloatingToBoolean");
+        case ZigClangCK_FloatingToBoolean:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingToBoolean");
             return nullptr;
-        case clang::CK_BooleanToSignedIntegral:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_BooleanToSignedIntegral");
+        case ZigClangCK_BooleanToSignedIntegral:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BooleanToSignedIntegral");
             return nullptr;
-        case clang::CK_FloatingCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FloatingCast");
+        case ZigClangCK_FloatingCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingCast");
             return nullptr;
-        case clang::CK_CPointerToObjCPointerCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_CPointerToObjCPointerCast");
+        case ZigClangCK_CPointerToObjCPointerCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_CPointerToObjCPointerCast");
             return nullptr;
-        case clang::CK_BlockPointerToObjCPointerCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_BlockPointerToObjCPointerCast");
+        case ZigClangCK_BlockPointerToObjCPointerCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BlockPointerToObjCPointerCast");
             return nullptr;
-        case clang::CK_AnyPointerToBlockPointerCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_AnyPointerToBlockPointerCast");
+        case ZigClangCK_AnyPointerToBlockPointerCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AnyPointerToBlockPointerCast");
             return nullptr;
-        case clang::CK_ObjCObjectLValueCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_ObjCObjectLValueCast");
+        case ZigClangCK_ObjCObjectLValueCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ObjCObjectLValueCast");
             return nullptr;
-        case clang::CK_FloatingRealToComplex:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FloatingRealToComplex");
+        case ZigClangCK_FloatingRealToComplex:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingRealToComplex");
             return nullptr;
-        case clang::CK_FloatingComplexToReal:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FloatingComplexToReal");
+        case ZigClangCK_FloatingComplexToReal:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToReal");
             return nullptr;
-        case clang::CK_FloatingComplexToBoolean:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FloatingComplexToBoolean");
+        case ZigClangCK_FloatingComplexToBoolean:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToBoolean");
             return nullptr;
-        case clang::CK_FloatingComplexCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FloatingComplexCast");
+        case ZigClangCK_FloatingComplexCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexCast");
             return nullptr;
-        case clang::CK_FloatingComplexToIntegralComplex:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_FloatingComplexToIntegralComplex");
+        case ZigClangCK_FloatingComplexToIntegralComplex:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToIntegralComplex");
             return nullptr;
-        case clang::CK_IntegralRealToComplex:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntegralRealToComplex");
+        case ZigClangCK_IntegralRealToComplex:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralRealToComplex");
             return nullptr;
-        case clang::CK_IntegralComplexToReal:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntegralComplexToReal");
+        case ZigClangCK_IntegralComplexToReal:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToReal");
             return nullptr;
-        case clang::CK_IntegralComplexToBoolean:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntegralComplexToBoolean");
+        case ZigClangCK_IntegralComplexToBoolean:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToBoolean");
             return nullptr;
-        case clang::CK_IntegralComplexCast:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntegralComplexCast");
+        case ZigClangCK_IntegralComplexCast:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexCast");
             return nullptr;
-        case clang::CK_IntegralComplexToFloatingComplex:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntegralComplexToFloatingComplex");
+        case ZigClangCK_IntegralComplexToFloatingComplex:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToFloatingComplex");
             return nullptr;
-        case clang::CK_ARCProduceObject:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_ARCProduceObject");
+        case ZigClangCK_ARCProduceObject:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCProduceObject");
             return nullptr;
-        case clang::CK_ARCConsumeObject:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_ARCConsumeObject");
+        case ZigClangCK_ARCConsumeObject:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCConsumeObject");
             return nullptr;
-        case clang::CK_ARCReclaimReturnedObject:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_ARCReclaimReturnedObject");
+        case ZigClangCK_ARCReclaimReturnedObject:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCReclaimReturnedObject");
             return nullptr;
-        case clang::CK_ARCExtendBlockObject:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_ARCExtendBlockObject");
+        case ZigClangCK_ARCExtendBlockObject:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCExtendBlockObject");
             return nullptr;
-        case clang::CK_AtomicToNonAtomic:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_AtomicToNonAtomic");
+        case ZigClangCK_AtomicToNonAtomic:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AtomicToNonAtomic");
             return nullptr;
-        case clang::CK_NonAtomicToAtomic:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_NonAtomicToAtomic");
+        case ZigClangCK_NonAtomicToAtomic:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_NonAtomicToAtomic");
             return nullptr;
-        case clang::CK_CopyAndAutoreleaseBlockObject:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_CopyAndAutoreleaseBlockObject");
+        case ZigClangCK_CopyAndAutoreleaseBlockObject:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_CopyAndAutoreleaseBlockObject");
             return nullptr;
-        case clang::CK_BuiltinFnToFnPtr:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_BuiltinFnToFnPtr");
+        case ZigClangCK_BuiltinFnToFnPtr:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BuiltinFnToFnPtr");
             return nullptr;
-        case clang::CK_ZeroToOCLOpaqueType:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_ZeroToOCLOpaqueType");
+        case ZigClangCK_ZeroToOCLOpaqueType:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ZeroToOCLOpaqueType");
             return nullptr;
-        case clang::CK_AddressSpaceConversion:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_AddressSpaceConversion");
+        case ZigClangCK_AddressSpaceConversion:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AddressSpaceConversion");
             return nullptr;
-        case clang::CK_IntToOCLSampler:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CK_IntToOCLSampler");
+        case ZigClangCK_IntToOCLSampler:
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntToOCLSampler");
             return nullptr;
     }
     zig_unreachable();
@@ -1993,7 +2160,7 @@ static AstNode *trans_implicit_cast_expr(Context *c, ResultUsed result_used, Tra
 
 static AstNode *trans_decl_ref_expr(Context *c, TransScope *scope, const clang::DeclRefExpr *stmt, TransLRValue lrval) {
     const clang::ValueDecl *value_decl = stmt->getDecl();
-    Buf *c_symbol_name = buf_create_from_str(decl_name(value_decl));
+    Buf *c_symbol_name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)value_decl));
     Buf *zig_symbol_name = trans_lookup_zig_symbol(c, scope, c_symbol_name);
     if (lrval == TransLValue) {
         c->ptr_params.put(zig_symbol_name, true);
@@ -2004,7 +2171,7 @@ static AstNode *trans_decl_ref_expr(Context *c, TransScope *scope, const clang::
 static AstNode *trans_create_post_crement(Context *c, ResultUsed result_used, TransScope *scope,
         const clang::UnaryOperator *stmt, BinOpType assign_op)
 {
-    clang::Expr *op_expr = stmt->getSubExpr();
+    const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
 
     if (result_used == ResultUsedNo) {
         // common case
@@ -2060,7 +2227,7 @@ static AstNode *trans_create_post_crement(Context *c, ResultUsed result_used, Tr
 static AstNode *trans_create_pre_crement(Context *c, ResultUsed result_used, TransScope *scope,
         const clang::UnaryOperator *stmt, BinOpType assign_op)
 {
-    clang::Expr *op_expr = stmt->getSubExpr();
+    const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
 
     if (result_used == ResultUsedNo) {
         // common case
@@ -2110,50 +2277,50 @@ static AstNode *trans_create_pre_crement(Context *c, ResultUsed result_used, Tra
 static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransScope *scope, const clang::UnaryOperator *stmt) {
     switch (stmt->getOpcode()) {
         case clang::UO_PostInc:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType()))
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
                 return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap);
             else
                 return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignPlus);
         case clang::UO_PostDec:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType()))
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
                 return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap);
             else
                 return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignMinus);
         case clang::UO_PreInc:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType()))
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
                 return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap);
             else
                 return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignPlus);
         case clang::UO_PreDec:
-            if (qual_type_has_wrapping_overflow(c, stmt->getType()))
+            if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
                 return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap);
             else
                 return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignMinus);
         case clang::UO_AddrOf:
             {
-                AstNode *value_node = trans_expr(c, result_used, scope, stmt->getSubExpr(), TransLValue);
+                AstNode *value_node = trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransLValue);
                 if (value_node == nullptr)
                     return value_node;
                 return trans_create_node_addr_of(c, value_node);
             }
         case clang::UO_Deref:
             {
-                AstNode *value_node = trans_expr(c, result_used, scope, stmt->getSubExpr(), TransRValue);
+                AstNode *value_node = trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransRValue);
                 if (value_node == nullptr)
                     return nullptr;
-                bool is_fn_ptr = qual_type_is_fn_ptr(stmt->getSubExpr()->getType());
+                bool is_fn_ptr = qual_type_is_fn_ptr(bitcast(stmt->getSubExpr()->getType()));
                 if (is_fn_ptr)
                     return value_node;
                 AstNode *unwrapped = trans_create_node_unwrap_null(c, value_node);
                 return trans_create_node_ptr_deref(c, unwrapped);
             }
         case clang::UO_Plus:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation UO_Plus");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation UO_Plus");
             return nullptr;
         case clang::UO_Minus:
             {
-                clang::Expr *op_expr = stmt->getSubExpr();
-                if (!qual_type_has_wrapping_overflow(c, op_expr->getType())) {
+                const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
+                if (!qual_type_has_wrapping_overflow(c, ZigClangExpr_getType(op_expr))) {
                     AstNode *node = trans_create_node(c, NodeTypePrefixOpExpr);
                     node->data.prefix_op_expr.prefix_op = PrefixOpNegation;
 
@@ -2162,7 +2329,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
                         return nullptr;
 
                     return node;
-                } else if (c_is_unsigned_integer(c, op_expr->getType())) {
+                } else if (c_is_unsigned_integer(c, ZigClangExpr_getType(op_expr))) {
                     // we gotta emit 0 -% x
                     AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
                     node->data.bin_op_expr.op1 = trans_create_node_unsigned(c, 0);
@@ -2174,13 +2341,13 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
                     node->data.bin_op_expr.bin_op = BinOpTypeSubWrap;
                     return node;
                 } else {
-                    emit_warning(c, stmt->getBeginLoc(), "C negation with non float non integer");
+                    emit_warning(c, bitcast(stmt->getBeginLoc()), "C negation with non float non integer");
                     return nullptr;
                 }
             }
         case clang::UO_Not:
             {
-                clang::Expr *op_expr = stmt->getSubExpr();
+                const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
                 AstNode *sub_node = trans_expr(c, ResultUsedYes, scope, op_expr, TransRValue);
                 if (sub_node == nullptr)
                     return nullptr;
@@ -2189,7 +2356,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
             }
         case clang::UO_LNot:
             {
-                clang::Expr *op_expr = stmt->getSubExpr();
+                const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
                 AstNode *sub_node = trans_bool_expr(c, ResultUsedYes, scope, op_expr, TransRValue);
                 if (sub_node == nullptr)
                     return nullptr;
@@ -2197,15 +2364,15 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
                 return trans_create_node_prefix_op(c, PrefixOpBoolNot, sub_node);
             }
         case clang::UO_Real:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation UO_Real");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation UO_Real");
             return nullptr;
         case clang::UO_Imag:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation UO_Imag");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation UO_Imag");
             return nullptr;
         case clang::UO_Extension:
-            return trans_expr(c, result_used, scope, stmt->getSubExpr(), TransLValue);
+            return trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransLValue);
         case clang::UO_Coawait:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C translation UO_Coawait");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation UO_Coawait");
             return nullptr;
     }
     zig_unreachable();
@@ -2225,249 +2392,250 @@ static int trans_local_declaration(Context *c, TransScope *scope, const clang::D
         switch (decl->getKind()) {
             case clang::Decl::Var: {
                 clang::VarDecl *var_decl = (clang::VarDecl *)decl;
-                clang::QualType qual_type = var_decl->getTypeSourceInfo()->getType();
+                ZigClangQualType qual_type = bitcast(var_decl->getTypeSourceInfo()->getType());
                 AstNode *init_node = nullptr;
                 if (var_decl->hasInit()) {
-                    init_node = trans_expr(c, ResultUsedYes, scope, var_decl->getInit(), TransRValue);
+                    init_node = trans_expr(c, ResultUsedYes, scope, bitcast(var_decl->getInit()), TransRValue);
                     if (init_node == nullptr)
                         return ErrorUnexpected;
 
                 } else {
                     init_node = trans_create_node(c, NodeTypeUndefinedLiteral);
                 }
-                AstNode *type_node = trans_qual_type(c, qual_type, stmt->getBeginLoc());
+                AstNode *type_node = trans_qual_type(c, qual_type, bitcast(stmt->getBeginLoc()));
                 if (type_node == nullptr)
                     return ErrorUnexpected;
 
-                Buf *c_symbol_name = buf_create_from_str(decl_name(var_decl));
+                Buf *c_symbol_name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)var_decl));
 
                 TransScopeVar *var_scope = trans_scope_var_create(c, scope, c_symbol_name);
                 scope = &var_scope->base;
 
-                AstNode *node = trans_create_node_var_decl_local(c, qual_type.isConstQualified(),
+                AstNode *node = trans_create_node_var_decl_local(c,
+                        ZigClangQualType_isConstQualified(qual_type),
                         var_scope->zig_name, type_node, init_node);
 
                 scope_block->node->data.block.statements.append(node);
                 continue;
             }
             case clang::Decl::AccessSpec:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle decl kind AccessSpec");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle decl kind AccessSpec");
                 return ErrorUnexpected;
             case clang::Decl::Block:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Block");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Block");
                 return ErrorUnexpected;
             case clang::Decl::Captured:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Captured");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Captured");
                 return ErrorUnexpected;
             case clang::Decl::ClassScopeFunctionSpecialization:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ClassScopeFunctionSpecialization");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ClassScopeFunctionSpecialization");
                 return ErrorUnexpected;
             case clang::Decl::Empty:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Empty");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Empty");
                 return ErrorUnexpected;
             case clang::Decl::Export:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Export");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Export");
                 return ErrorUnexpected;
             case clang::Decl::ExternCContext:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ExternCContext");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ExternCContext");
                 return ErrorUnexpected;
             case clang::Decl::FileScopeAsm:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C FileScopeAsm");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FileScopeAsm");
                 return ErrorUnexpected;
             case clang::Decl::Friend:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Friend");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Friend");
                 return ErrorUnexpected;
             case clang::Decl::FriendTemplate:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C FriendTemplate");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FriendTemplate");
                 return ErrorUnexpected;
             case clang::Decl::Import:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Import");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Import");
                 return ErrorUnexpected;
             case clang::Decl::LinkageSpec:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C LinkageSpec");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C LinkageSpec");
                 return ErrorUnexpected;
             case clang::Decl::Label:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Label");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Label");
                 return ErrorUnexpected;
             case clang::Decl::Namespace:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Namespace");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Namespace");
                 return ErrorUnexpected;
             case clang::Decl::NamespaceAlias:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C NamespaceAlias");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C NamespaceAlias");
                 return ErrorUnexpected;
             case clang::Decl::ObjCCompatibleAlias:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCCompatibleAlias");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCCompatibleAlias");
                 return ErrorUnexpected;
             case clang::Decl::ObjCCategory:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCCategory");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCCategory");
                 return ErrorUnexpected;
             case clang::Decl::ObjCCategoryImpl:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCCategoryImpl");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCCategoryImpl");
                 return ErrorUnexpected;
             case clang::Decl::ObjCImplementation:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCImplementation");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCImplementation");
                 return ErrorUnexpected;
             case clang::Decl::ObjCInterface:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCInterface");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCInterface");
                 return ErrorUnexpected;
             case clang::Decl::ObjCProtocol:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCProtocol");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCProtocol");
                 return ErrorUnexpected;
             case clang::Decl::ObjCMethod:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCMethod");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCMethod");
                 return ErrorUnexpected;
             case clang::Decl::ObjCProperty:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCProperty");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCProperty");
                 return ErrorUnexpected;
             case clang::Decl::BuiltinTemplate:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C BuiltinTemplate");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C BuiltinTemplate");
                 return ErrorUnexpected;
             case clang::Decl::ClassTemplate:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ClassTemplate");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ClassTemplate");
                 return ErrorUnexpected;
             case clang::Decl::FunctionTemplate:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C FunctionTemplate");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FunctionTemplate");
                 return ErrorUnexpected;
             case clang::Decl::TypeAliasTemplate:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C TypeAliasTemplate");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TypeAliasTemplate");
                 return ErrorUnexpected;
             case clang::Decl::VarTemplate:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C VarTemplate");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C VarTemplate");
                 return ErrorUnexpected;
             case clang::Decl::TemplateTemplateParm:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C TemplateTemplateParm");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TemplateTemplateParm");
                 return ErrorUnexpected;
             case clang::Decl::Enum:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Enum");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Enum");
                 return ErrorUnexpected;
             case clang::Decl::Record:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Record");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Record");
                 return ErrorUnexpected;
             case clang::Decl::CXXRecord:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXRecord");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXRecord");
                 return ErrorUnexpected;
             case clang::Decl::ClassTemplateSpecialization:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ClassTemplateSpecialization");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ClassTemplateSpecialization");
                 return ErrorUnexpected;
             case clang::Decl::ClassTemplatePartialSpecialization:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ClassTemplatePartialSpecialization");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ClassTemplatePartialSpecialization");
                 return ErrorUnexpected;
             case clang::Decl::TemplateTypeParm:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C TemplateTypeParm");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TemplateTypeParm");
                 return ErrorUnexpected;
             case clang::Decl::ObjCTypeParam:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCTypeParam");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCTypeParam");
                 return ErrorUnexpected;
             case clang::Decl::TypeAlias:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C TypeAlias");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TypeAlias");
                 return ErrorUnexpected;
             case clang::Decl::Typedef:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Typedef");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Typedef");
                 return ErrorUnexpected;
             case clang::Decl::UnresolvedUsingTypename:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C UnresolvedUsingTypename");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UnresolvedUsingTypename");
                 return ErrorUnexpected;
             case clang::Decl::Using:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Using");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Using");
                 return ErrorUnexpected;
             case clang::Decl::UsingDirective:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C UsingDirective");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UsingDirective");
                 return ErrorUnexpected;
             case clang::Decl::UsingPack:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C UsingPack");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UsingPack");
                 return ErrorUnexpected;
             case clang::Decl::UsingShadow:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C UsingShadow");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UsingShadow");
                 return ErrorUnexpected;
             case clang::Decl::ConstructorUsingShadow:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ConstructorUsingShadow");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ConstructorUsingShadow");
                 return ErrorUnexpected;
             case clang::Decl::Binding:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Binding");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Binding");
                 return ErrorUnexpected;
             case clang::Decl::Field:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Field");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Field");
                 return ErrorUnexpected;
             case clang::Decl::ObjCAtDefsField:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCAtDefsField");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtDefsField");
                 return ErrorUnexpected;
             case clang::Decl::ObjCIvar:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCIvar");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCIvar");
                 return ErrorUnexpected;
             case clang::Decl::Function:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Function");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Function");
                 return ErrorUnexpected;
             case clang::Decl::CXXDeductionGuide:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXDeductionGuide");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDeductionGuide");
                 return ErrorUnexpected;
             case clang::Decl::CXXMethod:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXMethod");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXMethod");
                 return ErrorUnexpected;
             case clang::Decl::CXXConstructor:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXConstructor");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXConstructor");
                 return ErrorUnexpected;
             case clang::Decl::CXXConversion:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXConversion");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXConversion");
                 return ErrorUnexpected;
             case clang::Decl::CXXDestructor:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXDestructor");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDestructor");
                 return ErrorUnexpected;
             case clang::Decl::MSProperty:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C MSProperty");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSProperty");
                 return ErrorUnexpected;
             case clang::Decl::NonTypeTemplateParm:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C NonTypeTemplateParm");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C NonTypeTemplateParm");
                 return ErrorUnexpected;
             case clang::Decl::Decomposition:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C Decomposition");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C Decomposition");
                 return ErrorUnexpected;
             case clang::Decl::ImplicitParam:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ImplicitParam");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ImplicitParam");
                 return ErrorUnexpected;
             case clang::Decl::OMPCapturedExpr:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPCapturedExpr");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPCapturedExpr");
                 return ErrorUnexpected;
             case clang::Decl::ParmVar:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ParmVar");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ParmVar");
                 return ErrorUnexpected;
             case clang::Decl::VarTemplateSpecialization:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C VarTemplateSpecialization");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C VarTemplateSpecialization");
                 return ErrorUnexpected;
             case clang::Decl::VarTemplatePartialSpecialization:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C VarTemplatePartialSpecialization");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C VarTemplatePartialSpecialization");
                 return ErrorUnexpected;
             case clang::Decl::EnumConstant:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C EnumConstant");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C EnumConstant");
                 return ErrorUnexpected;
             case clang::Decl::IndirectField:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C IndirectField");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C IndirectField");
                 return ErrorUnexpected;
             case clang::Decl::OMPDeclareReduction:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPDeclareReduction");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDeclareReduction");
                 return ErrorUnexpected;
             case clang::Decl::UnresolvedUsingValue:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C UnresolvedUsingValue");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UnresolvedUsingValue");
                 return ErrorUnexpected;
             case clang::Decl::OMPRequires:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPRequires");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPRequires");
                 return ErrorUnexpected;
             case clang::Decl::OMPThreadPrivate:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPThreadPrivate");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPThreadPrivate");
                 return ErrorUnexpected;
             case clang::Decl::ObjCPropertyImpl:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCPropertyImpl");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCPropertyImpl");
                 return ErrorUnexpected;
             case clang::Decl::PragmaComment:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C PragmaComment");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C PragmaComment");
                 return ErrorUnexpected;
             case clang::Decl::PragmaDetectMismatch:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C PragmaDetectMismatch");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C PragmaDetectMismatch");
                 return ErrorUnexpected;
             case clang::Decl::StaticAssert:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C StaticAssert");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C StaticAssert");
                 return ErrorUnexpected;
             case clang::Decl::TranslationUnit:
-                emit_warning(c, stmt->getBeginLoc(), "TODO handle C TranslationUnit");
+                emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TranslationUnit");
                 return ErrorUnexpected;
         }
         zig_unreachable();
@@ -2493,7 +2661,7 @@ static AstNode *to_enum_zero_cmp(Context *c, AstNode *expr, AstNode *enum_type)
     return trans_create_node_bin_op(c, expr, BinOpTypeCmpNotEq, bitcast);
 }
 
-static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval) {
+static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval) {
     AstNode *res = trans_expr(c, result_used, scope, expr, lrval);
     if (res == nullptr)
         return nullptr;
@@ -2530,146 +2698,145 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
     }
 
 
-    const clang::Type *ty = get_expr_qual_type_before_implicit_cast(c, expr).getTypePtr();
-    auto classs = ty->getTypeClass();
+    const ZigClangType *ty = ZigClangQualType_getTypePtr(get_expr_qual_type_before_implicit_cast(c, expr));
+    auto classs = ZigClangType_getTypeClass(ty);
     switch (classs) {
-        case clang::Type::Builtin:
+        case ZigClangType_Builtin:
         {
-            const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(ty);
-            switch (builtin_ty->getKind()) {
-                case clang::BuiltinType::Bool:
-                case clang::BuiltinType::Char_U:
-                case clang::BuiltinType::UChar:
-                case clang::BuiltinType::Char_S:
-                case clang::BuiltinType::SChar:
-                case clang::BuiltinType::UShort:
-                case clang::BuiltinType::UInt:
-                case clang::BuiltinType::ULong:
-                case clang::BuiltinType::ULongLong:
-                case clang::BuiltinType::Short:
-                case clang::BuiltinType::Int:
-                case clang::BuiltinType::Long:
-                case clang::BuiltinType::LongLong:
-                case clang::BuiltinType::UInt128:
-                case clang::BuiltinType::Int128:
-                case clang::BuiltinType::Float:
-                case clang::BuiltinType::Double:
-                case clang::BuiltinType::Float128:
-                case clang::BuiltinType::LongDouble:
-                case clang::BuiltinType::WChar_U:
-                case clang::BuiltinType::Char8:
-                case clang::BuiltinType::Char16:
-                case clang::BuiltinType::Char32:
-                case clang::BuiltinType::WChar_S:
-                case clang::BuiltinType::Float16:
+            const ZigClangBuiltinType *builtin_ty = reinterpret_cast<const ZigClangBuiltinType*>(ty);
+            switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+                case ZigClangBuiltinTypeBool:
+                case ZigClangBuiltinTypeChar_U:
+                case ZigClangBuiltinTypeUChar:
+                case ZigClangBuiltinTypeChar_S:
+                case ZigClangBuiltinTypeSChar:
+                case ZigClangBuiltinTypeUShort:
+                case ZigClangBuiltinTypeUInt:
+                case ZigClangBuiltinTypeULong:
+                case ZigClangBuiltinTypeULongLong:
+                case ZigClangBuiltinTypeShort:
+                case ZigClangBuiltinTypeInt:
+                case ZigClangBuiltinTypeLong:
+                case ZigClangBuiltinTypeLongLong:
+                case ZigClangBuiltinTypeUInt128:
+                case ZigClangBuiltinTypeInt128:
+                case ZigClangBuiltinTypeFloat:
+                case ZigClangBuiltinTypeDouble:
+                case ZigClangBuiltinTypeFloat128:
+                case ZigClangBuiltinTypeLongDouble:
+                case ZigClangBuiltinTypeWChar_U:
+                case ZigClangBuiltinTypeChar8:
+                case ZigClangBuiltinTypeChar16:
+                case ZigClangBuiltinTypeChar32:
+                case ZigClangBuiltinTypeWChar_S:
+                case ZigClangBuiltinTypeFloat16:
                     return trans_create_node_bin_op(c, res, BinOpTypeCmpNotEq, trans_create_node_unsigned_negative(c, 0, false));
-                case clang::BuiltinType::NullPtr:
+                case ZigClangBuiltinTypeNullPtr:
                     return trans_create_node_bin_op(c, res, BinOpTypeCmpNotEq,
-                            trans_create_node_unsigned(c, 0));
-
-                case clang::BuiltinType::Void:
-                case clang::BuiltinType::Half:
-                case clang::BuiltinType::ObjCId:
-                case clang::BuiltinType::ObjCClass:
-                case clang::BuiltinType::ObjCSel:
-                case clang::BuiltinType::OMPArraySection:
-                case clang::BuiltinType::Dependent:
-                case clang::BuiltinType::Overload:
-                case clang::BuiltinType::BoundMember:
-                case clang::BuiltinType::PseudoObject:
-                case clang::BuiltinType::UnknownAny:
-                case clang::BuiltinType::BuiltinFn:
-                case clang::BuiltinType::ARCUnbridgedCast:
-                case clang::BuiltinType::OCLImage1dRO:
-                case clang::BuiltinType::OCLImage1dArrayRO:
-                case clang::BuiltinType::OCLImage1dBufferRO:
-                case clang::BuiltinType::OCLImage2dRO:
-                case clang::BuiltinType::OCLImage2dArrayRO:
-                case clang::BuiltinType::OCLImage2dDepthRO:
-                case clang::BuiltinType::OCLImage2dArrayDepthRO:
-                case clang::BuiltinType::OCLImage2dMSAARO:
-                case clang::BuiltinType::OCLImage2dArrayMSAARO:
-                case clang::BuiltinType::OCLImage2dMSAADepthRO:
-                case clang::BuiltinType::OCLImage2dArrayMSAADepthRO:
-                case clang::BuiltinType::OCLImage3dRO:
-                case clang::BuiltinType::OCLImage1dWO:
-                case clang::BuiltinType::OCLImage1dArrayWO:
-                case clang::BuiltinType::OCLImage1dBufferWO:
-                case clang::BuiltinType::OCLImage2dWO:
-                case clang::BuiltinType::OCLImage2dArrayWO:
-                case clang::BuiltinType::OCLImage2dDepthWO:
-                case clang::BuiltinType::OCLImage2dArrayDepthWO:
-                case clang::BuiltinType::OCLImage2dMSAAWO:
-                case clang::BuiltinType::OCLImage2dArrayMSAAWO:
-                case clang::BuiltinType::OCLImage2dMSAADepthWO:
-                case clang::BuiltinType::OCLImage2dArrayMSAADepthWO:
-                case clang::BuiltinType::OCLImage3dWO:
-                case clang::BuiltinType::OCLImage1dRW:
-                case clang::BuiltinType::OCLImage1dArrayRW:
-                case clang::BuiltinType::OCLImage1dBufferRW:
-                case clang::BuiltinType::OCLImage2dRW:
-                case clang::BuiltinType::OCLImage2dArrayRW:
-                case clang::BuiltinType::OCLImage2dDepthRW:
-                case clang::BuiltinType::OCLImage2dArrayDepthRW:
-                case clang::BuiltinType::OCLImage2dMSAARW:
-                case clang::BuiltinType::OCLImage2dArrayMSAARW:
-                case clang::BuiltinType::OCLImage2dMSAADepthRW:
-                case clang::BuiltinType::OCLImage2dArrayMSAADepthRW:
-                case clang::BuiltinType::OCLImage3dRW:
-                case clang::BuiltinType::OCLSampler:
-                case clang::BuiltinType::OCLEvent:
-                case clang::BuiltinType::OCLClkEvent:
-                case clang::BuiltinType::OCLQueue:
-                case clang::BuiltinType::OCLReserveID:
-                case clang::BuiltinType::ShortAccum:
-                case clang::BuiltinType::Accum:
-                case clang::BuiltinType::LongAccum:
-                case clang::BuiltinType::UShortAccum:
-                case clang::BuiltinType::UAccum:
-                case clang::BuiltinType::ULongAccum:
-                case clang::BuiltinType::ShortFract:
-                case clang::BuiltinType::Fract:
-                case clang::BuiltinType::LongFract:
-                case clang::BuiltinType::UShortFract:
-                case clang::BuiltinType::UFract:
-                case clang::BuiltinType::ULongFract:
-                case clang::BuiltinType::SatShortAccum:
-                case clang::BuiltinType::SatAccum:
-                case clang::BuiltinType::SatLongAccum:
-                case clang::BuiltinType::SatUShortAccum:
-                case clang::BuiltinType::SatUAccum:
-                case clang::BuiltinType::SatULongAccum:
-                case clang::BuiltinType::SatShortFract:
-                case clang::BuiltinType::SatFract:
-                case clang::BuiltinType::SatLongFract:
-                case clang::BuiltinType::SatUShortFract:
-                case clang::BuiltinType::SatUFract:
-                case clang::BuiltinType::SatULongFract:
-                case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload:
-                case clang::BuiltinType::OCLIntelSubgroupAVCImePayload:
-                case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload:
-                case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload:
-                case clang::BuiltinType::OCLIntelSubgroupAVCMceResult:
-                case clang::BuiltinType::OCLIntelSubgroupAVCImeResult:
-                case clang::BuiltinType::OCLIntelSubgroupAVCRefResult:
-                case clang::BuiltinType::OCLIntelSubgroupAVCSicResult:
-                case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout:
-                case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout:
-                case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin:
-                case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin:
+                            trans_create_node(c, NodeTypeNullLiteral));
+
+                case ZigClangBuiltinTypeVoid:
+                case ZigClangBuiltinTypeHalf:
+                case ZigClangBuiltinTypeObjCId:
+                case ZigClangBuiltinTypeObjCClass:
+                case ZigClangBuiltinTypeObjCSel:
+                case ZigClangBuiltinTypeOMPArraySection:
+                case ZigClangBuiltinTypeDependent:
+                case ZigClangBuiltinTypeOverload:
+                case ZigClangBuiltinTypeBoundMember:
+                case ZigClangBuiltinTypePseudoObject:
+                case ZigClangBuiltinTypeUnknownAny:
+                case ZigClangBuiltinTypeBuiltinFn:
+                case ZigClangBuiltinTypeARCUnbridgedCast:
+                case ZigClangBuiltinTypeOCLImage1dRO:
+                case ZigClangBuiltinTypeOCLImage1dArrayRO:
+                case ZigClangBuiltinTypeOCLImage1dBufferRO:
+                case ZigClangBuiltinTypeOCLImage2dRO:
+                case ZigClangBuiltinTypeOCLImage2dArrayRO:
+                case ZigClangBuiltinTypeOCLImage2dDepthRO:
+                case ZigClangBuiltinTypeOCLImage2dArrayDepthRO:
+                case ZigClangBuiltinTypeOCLImage2dMSAARO:
+                case ZigClangBuiltinTypeOCLImage2dArrayMSAARO:
+                case ZigClangBuiltinTypeOCLImage2dMSAADepthRO:
+                case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRO:
+                case ZigClangBuiltinTypeOCLImage3dRO:
+                case ZigClangBuiltinTypeOCLImage1dWO:
+                case ZigClangBuiltinTypeOCLImage1dArrayWO:
+                case ZigClangBuiltinTypeOCLImage1dBufferWO:
+                case ZigClangBuiltinTypeOCLImage2dWO:
+                case ZigClangBuiltinTypeOCLImage2dArrayWO:
+                case ZigClangBuiltinTypeOCLImage2dDepthWO:
+                case ZigClangBuiltinTypeOCLImage2dArrayDepthWO:
+                case ZigClangBuiltinTypeOCLImage2dMSAAWO:
+                case ZigClangBuiltinTypeOCLImage2dArrayMSAAWO:
+                case ZigClangBuiltinTypeOCLImage2dMSAADepthWO:
+                case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthWO:
+                case ZigClangBuiltinTypeOCLImage3dWO:
+                case ZigClangBuiltinTypeOCLImage1dRW:
+                case ZigClangBuiltinTypeOCLImage1dArrayRW:
+                case ZigClangBuiltinTypeOCLImage1dBufferRW:
+                case ZigClangBuiltinTypeOCLImage2dRW:
+                case ZigClangBuiltinTypeOCLImage2dArrayRW:
+                case ZigClangBuiltinTypeOCLImage2dDepthRW:
+                case ZigClangBuiltinTypeOCLImage2dArrayDepthRW:
+                case ZigClangBuiltinTypeOCLImage2dMSAARW:
+                case ZigClangBuiltinTypeOCLImage2dArrayMSAARW:
+                case ZigClangBuiltinTypeOCLImage2dMSAADepthRW:
+                case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRW:
+                case ZigClangBuiltinTypeOCLImage3dRW:
+                case ZigClangBuiltinTypeOCLSampler:
+                case ZigClangBuiltinTypeOCLEvent:
+                case ZigClangBuiltinTypeOCLClkEvent:
+                case ZigClangBuiltinTypeOCLQueue:
+                case ZigClangBuiltinTypeOCLReserveID:
+                case ZigClangBuiltinTypeShortAccum:
+                case ZigClangBuiltinTypeAccum:
+                case ZigClangBuiltinTypeLongAccum:
+                case ZigClangBuiltinTypeUShortAccum:
+                case ZigClangBuiltinTypeUAccum:
+                case ZigClangBuiltinTypeULongAccum:
+                case ZigClangBuiltinTypeShortFract:
+                case ZigClangBuiltinTypeFract:
+                case ZigClangBuiltinTypeLongFract:
+                case ZigClangBuiltinTypeUShortFract:
+                case ZigClangBuiltinTypeUFract:
+                case ZigClangBuiltinTypeULongFract:
+                case ZigClangBuiltinTypeSatShortAccum:
+                case ZigClangBuiltinTypeSatAccum:
+                case ZigClangBuiltinTypeSatLongAccum:
+                case ZigClangBuiltinTypeSatUShortAccum:
+                case ZigClangBuiltinTypeSatUAccum:
+                case ZigClangBuiltinTypeSatULongAccum:
+                case ZigClangBuiltinTypeSatShortFract:
+                case ZigClangBuiltinTypeSatFract:
+                case ZigClangBuiltinTypeSatLongFract:
+                case ZigClangBuiltinTypeSatUShortFract:
+                case ZigClangBuiltinTypeSatUFract:
+                case ZigClangBuiltinTypeSatULongFract:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCMcePayload:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCImePayload:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCRefPayload:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCSicPayload:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCMceResult:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResult:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCRefResult:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCSicResult:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultSingleRefStreamout:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultDualRefStreamout:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeSingleRefStreamin:
+                case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeDualRefStreamin:
                     return res;
             }
             break;
         }
-        case clang::Type::Pointer:
-            return trans_create_node_bin_op(c, res, BinOpTypeCmpNotEq,
-                    trans_create_node_unsigned(c, 0));
+        case ZigClangType_Pointer:
+            return trans_create_node_bin_op(c, res, BinOpTypeCmpNotEq, trans_create_node(c, NodeTypeNullLiteral));
 
-        case clang::Type::Typedef:
+        case ZigClangType_Typedef:
         {
-            const clang::TypedefType *typedef_ty = static_cast<const clang::TypedefType*>(ty);
-            const clang::TypedefNameDecl *typedef_decl = typedef_ty->getDecl();
-            auto existing_entry = c->decl_table.maybe_get((void*)typedef_decl->getCanonicalDecl());
+            const ZigClangTypedefType *typedef_ty = reinterpret_cast<const ZigClangTypedefType*>(ty);
+            const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
+            auto existing_entry = c->decl_table.maybe_get((void*)ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl));
             if (existing_entry) {
                 return existing_entry->value;
             }
@@ -2677,19 +2844,20 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
             return res;
         }
 
-        case clang::Type::Enum:
+        case ZigClangType_Enum:
         {
-            const clang::EnumType *enum_ty = static_cast<const clang::EnumType*>(ty);
-            AstNode *enum_type = resolve_enum_decl(c, enum_ty->getDecl());
+            const ZigClangEnumType *enum_ty = reinterpret_cast<const ZigClangEnumType *>(ty);
+            AstNode *enum_type = resolve_enum_decl(c, ZigClangEnumType_getDecl(enum_ty));
             return to_enum_zero_cmp(c, res, enum_type);
         }
 
-        case clang::Type::Elaborated:
+        case ZigClangType_Elaborated:
         {
-            const clang::ElaboratedType *elaborated_ty = static_cast<const clang::ElaboratedType*>(ty);
+            const clang::ElaboratedType *elaborated_ty = reinterpret_cast<const clang::ElaboratedType*>(ty);
             switch (elaborated_ty->getKeyword()) {
                 case clang::ETK_Enum: {
-                    AstNode *enum_type = trans_qual_type(c, elaborated_ty->getNamedType(), expr->getBeginLoc());
+                    AstNode *enum_type = trans_qual_type(c, bitcast(elaborated_ty->getNamedType()),
+                            ZigClangExpr_getBeginLoc(expr));
                     return to_enum_zero_cmp(c, res, enum_type);
                 }
                 case clang::ETK_Struct:
@@ -2702,48 +2870,48 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
             }
         }
 
-        case clang::Type::FunctionProto:
-        case clang::Type::Record:
-        case clang::Type::ConstantArray:
-        case clang::Type::Paren:
-        case clang::Type::Decayed:
-        case clang::Type::Attributed:
-        case clang::Type::IncompleteArray:
-        case clang::Type::BlockPointer:
-        case clang::Type::LValueReference:
-        case clang::Type::RValueReference:
-        case clang::Type::MemberPointer:
-        case clang::Type::VariableArray:
-        case clang::Type::DependentSizedArray:
-        case clang::Type::DependentSizedExtVector:
-        case clang::Type::Vector:
-        case clang::Type::ExtVector:
-        case clang::Type::FunctionNoProto:
-        case clang::Type::UnresolvedUsing:
-        case clang::Type::Adjusted:
-        case clang::Type::TypeOfExpr:
-        case clang::Type::TypeOf:
-        case clang::Type::Decltype:
-        case clang::Type::UnaryTransform:
-        case clang::Type::TemplateTypeParm:
-        case clang::Type::SubstTemplateTypeParm:
-        case clang::Type::SubstTemplateTypeParmPack:
-        case clang::Type::TemplateSpecialization:
-        case clang::Type::Auto:
-        case clang::Type::InjectedClassName:
-        case clang::Type::DependentName:
-        case clang::Type::DependentTemplateSpecialization:
-        case clang::Type::PackExpansion:
-        case clang::Type::ObjCObject:
-        case clang::Type::ObjCInterface:
-        case clang::Type::Complex:
-        case clang::Type::ObjCObjectPointer:
-        case clang::Type::Atomic:
-        case clang::Type::Pipe:
-        case clang::Type::ObjCTypeParam:
-        case clang::Type::DeducedTemplateSpecialization:
-        case clang::Type::DependentAddressSpace:
-        case clang::Type::DependentVector:
+        case ZigClangType_FunctionProto:
+        case ZigClangType_Record:
+        case ZigClangType_ConstantArray:
+        case ZigClangType_Paren:
+        case ZigClangType_Decayed:
+        case ZigClangType_Attributed:
+        case ZigClangType_IncompleteArray:
+        case ZigClangType_BlockPointer:
+        case ZigClangType_LValueReference:
+        case ZigClangType_RValueReference:
+        case ZigClangType_MemberPointer:
+        case ZigClangType_VariableArray:
+        case ZigClangType_DependentSizedArray:
+        case ZigClangType_DependentSizedExtVector:
+        case ZigClangType_Vector:
+        case ZigClangType_ExtVector:
+        case ZigClangType_FunctionNoProto:
+        case ZigClangType_UnresolvedUsing:
+        case ZigClangType_Adjusted:
+        case ZigClangType_TypeOfExpr:
+        case ZigClangType_TypeOf:
+        case ZigClangType_Decltype:
+        case ZigClangType_UnaryTransform:
+        case ZigClangType_TemplateTypeParm:
+        case ZigClangType_SubstTemplateTypeParm:
+        case ZigClangType_SubstTemplateTypeParmPack:
+        case ZigClangType_TemplateSpecialization:
+        case ZigClangType_Auto:
+        case ZigClangType_InjectedClassName:
+        case ZigClangType_DependentName:
+        case ZigClangType_DependentTemplateSpecialization:
+        case ZigClangType_PackExpansion:
+        case ZigClangType_ObjCObject:
+        case ZigClangType_ObjCInterface:
+        case ZigClangType_Complex:
+        case ZigClangType_ObjCObjectPointer:
+        case ZigClangType_Atomic:
+        case ZigClangType_Pipe:
+        case ZigClangType_ObjCTypeParam:
+        case ZigClangType_DeducedTemplateSpecialization:
+        case ZigClangType_DependentAddressSpace:
+        case ZigClangType_DependentVector:
             return res;
     }
     zig_unreachable();
@@ -2752,11 +2920,12 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
 static AstNode *trans_while_loop(Context *c, TransScope *scope, const clang::WhileStmt *stmt) {
     TransScopeWhile *while_scope = trans_scope_while_create(c, scope);
 
-    while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, stmt->getCond(), TransRValue);
+    while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, scope,
+            bitcast(stmt->getCond()), TransRValue);
     if (while_scope->node->data.while_expr.condition == nullptr)
         return nullptr;
 
-    TransScope *body_scope = trans_stmt(c, &while_scope->base, stmt->getBody(),
+    TransScope *body_scope = trans_stmt(c, &while_scope->base, bitcast(stmt->getBody()),
             &while_scope->node->data.while_expr.body);
     if (body_scope == nullptr)
         return nullptr;
@@ -2769,17 +2938,18 @@ static AstNode *trans_if_statement(Context *c, TransScope *scope, const clang::I
     // if (c) t else e
     AstNode *if_node = trans_create_node(c, NodeTypeIfBoolExpr);
 
-    TransScope *then_scope = trans_stmt(c, scope, stmt->getThen(), &if_node->data.if_bool_expr.then_block);
+    TransScope *then_scope = trans_stmt(c, scope, bitcast(stmt->getThen()), &if_node->data.if_bool_expr.then_block);
     if (then_scope == nullptr)
         return nullptr;
 
     if (stmt->getElse() != nullptr) {
-        TransScope *else_scope = trans_stmt(c, scope, stmt->getElse(), &if_node->data.if_bool_expr.else_node);
+        TransScope *else_scope = trans_stmt(c, scope, bitcast(stmt->getElse()), &if_node->data.if_bool_expr.else_node);
         if (else_scope == nullptr)
             return nullptr;
     }
 
-    if_node->data.if_bool_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, stmt->getCond(), TransRValue);
+    if_node->data.if_bool_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, bitcast(stmt->getCond()),
+            TransRValue);
     if (if_node->data.if_bool_expr.condition == nullptr)
         return nullptr;
 
@@ -2789,18 +2959,18 @@ static AstNode *trans_if_statement(Context *c, TransScope *scope, const clang::I
 static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::CallExpr *stmt) {
     AstNode *node = trans_create_node(c, NodeTypeFnCallExpr);
 
-    AstNode *callee_raw_node = trans_expr(c, ResultUsedYes, scope, stmt->getCallee(), TransRValue);
+    AstNode *callee_raw_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getCallee()), TransRValue);
     if (callee_raw_node == nullptr)
         return nullptr;
 
     bool is_ptr = false;
-    const clang::FunctionProtoType *fn_ty = qual_type_get_fn_proto(stmt->getCallee()->getType(), &is_ptr);
+    const clang::FunctionProtoType *fn_ty = qual_type_get_fn_proto(bitcast(stmt->getCallee()->getType()), &is_ptr);
     AstNode *callee_node = nullptr;
     if (is_ptr && fn_ty) {
-        if (stmt->getCallee()->getStmtClass() == clang::Stmt::ImplicitCastExprClass) {
+        if ((ZigClangStmtClass)stmt->getCallee()->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) {
             const clang::ImplicitCastExpr *implicit_cast = static_cast<const clang::ImplicitCastExpr *>(stmt->getCallee());
-            if (implicit_cast->getCastKind() == clang::CK_FunctionToPointerDecay) {
-                if (implicit_cast->getSubExpr()->getStmtClass() == clang::Stmt::DeclRefExprClass) {
+            if ((ZigClangCK)implicit_cast->getCastKind() == ZigClangCK_FunctionToPointerDecay) {
+                if ((ZigClangStmtClass)implicit_cast->getSubExpr()->getStmtClass() == ZigClangStmt_DeclRefExprClass) {
                     const clang::DeclRefExpr *decl_ref = static_cast<const clang::DeclRefExpr *>(implicit_cast->getSubExpr());
                     const clang::Decl *decl = decl_ref->getFoundDecl();
                     if (decl->getKind() == clang::Decl::Function) {
@@ -2819,7 +2989,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
     node->data.fn_call_expr.fn_ref_expr = callee_node;
 
     unsigned num_args = stmt->getNumArgs();
-    const clang::Expr * const* args = stmt->getArgs();
+    const ZigClangExpr * const* args = reinterpret_cast<const ZigClangExpr * const*>(stmt->getArgs());
     for (unsigned i = 0; i < num_args; i += 1) {
         AstNode *arg_node = trans_expr(c, ResultUsedYes, scope, args[i], TransRValue);
         if (arg_node == nullptr)
@@ -2828,7 +2998,9 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
         node->data.fn_call_expr.params.append(arg_node);
     }
 
-    if (result_used == ResultUsedNo && fn_ty && !qual_type_canon(fn_ty->getReturnType())->isVoidType()) {
+    if (result_used == ResultUsedNo && fn_ty &&
+        !ZigClangType_isVoidType(qual_type_canon(bitcast(fn_ty->getReturnType()))))
+    {
         node = trans_create_node_bin_op(c, trans_create_node_symbol_str(c, "_"), BinOpTypeAssign, node);
     }
 
@@ -2838,7 +3010,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
 static AstNode *trans_member_expr(Context *c, ResultUsed result_used, TransScope *scope,
     const clang::MemberExpr *stmt)
 {
-    AstNode *container_node = trans_expr(c, ResultUsedYes, scope, stmt->getBase(), TransRValue);
+    AstNode *container_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getBase()), TransRValue);
     if (container_node == nullptr)
         return nullptr;
 
@@ -2846,18 +3018,18 @@ static AstNode *trans_member_expr(Context *c, ResultUsed result_used, TransScope
         container_node = trans_create_node_unwrap_null(c, container_node);
     }
 
-    const char *name = decl_name(stmt->getMemberDecl());
+    const char *name = ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)stmt->getMemberDecl());
 
     AstNode *node = trans_create_node_field_access_str(c, container_node, name);
     return maybe_suppress_result(c, result_used, node);
 }
 
 static AstNode *trans_array_subscript_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::ArraySubscriptExpr *stmt) {
-    AstNode *container_node = trans_expr(c, ResultUsedYes, scope, stmt->getBase(), TransRValue);
+    AstNode *container_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getBase()), TransRValue);
     if (container_node == nullptr)
         return nullptr;
 
-    AstNode *idx_node = trans_expr(c, ResultUsedYes, scope, stmt->getIdx(), TransRValue);
+    AstNode *idx_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getIdx()), TransRValue);
     if (idx_node == nullptr)
         return nullptr;
 
@@ -2871,11 +3043,12 @@ static AstNode *trans_array_subscript_expr(Context *c, ResultUsed result_used, T
 static AstNode *trans_c_style_cast_expr(Context *c, ResultUsed result_used, TransScope *scope,
         const clang::CStyleCastExpr *stmt, TransLRValue lrvalue)
 {
-    AstNode *sub_expr_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), lrvalue);
+    AstNode *sub_expr_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), lrvalue);
     if (sub_expr_node == nullptr)
         return nullptr;
 
-    AstNode *cast = trans_c_cast(c, stmt->getBeginLoc(), stmt->getType(), stmt->getSubExpr()->getType(), sub_expr_node);
+    AstNode *cast = trans_c_cast(c, bitcast(stmt->getBeginLoc()), bitcast(stmt->getType()),
+            bitcast(stmt->getSubExpr()->getType()), sub_expr_node);
     if (cast == nullptr)
         return nullptr;
 
@@ -2885,7 +3058,7 @@ static AstNode *trans_c_style_cast_expr(Context *c, ResultUsed result_used, Tran
 static AstNode *trans_unary_expr_or_type_trait_expr(Context *c, ResultUsed result_used,
         TransScope *scope, const clang::UnaryExprOrTypeTraitExpr *stmt)
 {
-    AstNode *type_node = trans_qual_type(c, stmt->getTypeOfArgument(), stmt->getBeginLoc());
+    AstNode *type_node = trans_qual_type(c, bitcast(stmt->getTypeOfArgument()), bitcast(stmt->getBeginLoc()));
     if (type_node == nullptr)
         return nullptr;
 
@@ -2901,7 +3074,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang:
 
     AstNode *body_node;
     TransScope *child_scope;
-    if (stmt->getBody()->getStmtClass() == clang::Stmt::CompoundStmtClass) {
+    if ((ZigClangStmtClass)stmt->getBody()->getStmtClass() == ZigClangStmt_CompoundStmtClass) {
         // there's already a block in C, so we'll append our condition to it.
         // c: do {
         // c:   a;
@@ -2914,7 +3087,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang:
         // zig: }
 
         // We call the low level function so that we can set child_scope to the scope of the generated block.
-        if (trans_stmt_extra(c, &while_scope->base, stmt->getBody(), ResultUsedNo, TransRValue, &body_node,
+        if (trans_stmt_extra(c, &while_scope->base, bitcast(stmt->getBody()), ResultUsedNo, TransRValue, &body_node,
             nullptr, &child_scope))
         {
             return nullptr;
@@ -2932,7 +3105,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang:
         TransScopeBlock *child_block_scope = trans_scope_block_create(c, &while_scope->base);
         body_node = child_block_scope->node;
         AstNode *child_statement;
-        child_scope = trans_stmt(c, &child_block_scope->base, stmt->getBody(), &child_statement);
+        child_scope = trans_stmt(c, &child_block_scope->base, bitcast(stmt->getBody()), &child_statement);
         if (child_scope == nullptr) return nullptr;
         if (child_statement != nullptr) {
             body_node->data.block.statements.append(child_statement);
@@ -2940,7 +3113,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang:
     }
 
     // if (!cond) break;
-    AstNode *condition_node = trans_expr(c, ResultUsedYes, child_scope, stmt->getCond(), TransRValue);
+    AstNode *condition_node = trans_expr(c, ResultUsedYes, child_scope, bitcast(stmt->getCond()), TransRValue);
     if (condition_node == nullptr) return nullptr;
     AstNode *terminator_node = trans_create_node(c, NodeTypeIfBoolExpr);
     terminator_node->data.if_bool_expr.condition = trans_create_node_prefix_op(c, PrefixOpBoolNot, condition_node);
@@ -2958,7 +3131,7 @@ static AstNode *trans_for_loop(Context *c, TransScope *parent_scope, const clang
     AstNode *loop_block_node;
     TransScopeWhile *while_scope;
     TransScope *cond_scope;
-    const clang::Stmt *init_stmt = stmt->getInit();
+    const ZigClangStmt *init_stmt = bitcast(stmt->getInit());
     if (init_stmt == nullptr) {
         while_scope = trans_scope_while_create(c, parent_scope);
         loop_block_node = while_scope->node;
@@ -2979,35 +3152,27 @@ static AstNode *trans_for_loop(Context *c, TransScope *parent_scope, const clang
         child_scope->node->data.block.statements.append(while_scope->node);
     }
 
-    const clang::Stmt *cond_stmt = stmt->getCond();
-    if (cond_stmt == nullptr) {
+    const ZigClangExpr *cond_expr = bitcast(stmt->getCond());
+    if (cond_expr == nullptr) {
         while_scope->node->data.while_expr.condition = trans_create_node_bool(c, true);
     } else {
-        if (clang::Expr::classof(cond_stmt)) {
-            const clang::Expr *cond_expr = static_cast<const clang::Expr*>(cond_stmt);
-            while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, cond_scope, cond_expr, TransRValue);
+        while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, cond_scope,
+                cond_expr, TransRValue);
 
-            if (while_scope->node->data.while_expr.condition == nullptr)
-                return nullptr;
-        } else {
-            TransScope *end_cond_scope = trans_stmt(c, cond_scope, cond_stmt,
-                                                    &while_scope->node->data.while_expr.condition);
-            if (end_cond_scope == nullptr)
-                return nullptr;
-        }
+        if (while_scope->node->data.while_expr.condition == nullptr)
+            return nullptr;
     }
 
-    const clang::Stmt *inc_stmt = stmt->getInc();
-    if (inc_stmt != nullptr) {
-        AstNode *inc_node;
-        TransScope *inc_scope = trans_stmt(c, cond_scope, inc_stmt, &inc_node);
-        if (inc_scope == nullptr)
+    const ZigClangExpr *inc_expr = bitcast(stmt->getInc());
+    if (inc_expr != nullptr) {
+        AstNode *inc_node = trans_expr(c, ResultUsedNo, cond_scope, inc_expr, TransRValue);
+        if (inc_node == nullptr)
             return nullptr;
         while_scope->node->data.while_expr.continue_expr = inc_node;
     }
 
     AstNode *body_statement;
-    TransScope *body_scope = trans_stmt(c, &while_scope->base, stmt->getBody(), &body_statement);
+    TransScope *body_scope = trans_stmt(c, &while_scope->base, bitcast(stmt->getBody()), &body_statement);
     if (body_scope == nullptr)
         return nullptr;
 
@@ -3030,7 +3195,7 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl
         switch_scope = trans_scope_switch_create(c, &block_scope->base);
     } else {
         AstNode *vars_node;
-        TransScope *var_scope = trans_stmt(c, &block_scope->base, var_decl_stmt, &vars_node);
+        TransScope *var_scope = trans_stmt(c, &block_scope->base, (const ZigClangStmt *)var_decl_stmt, &vars_node);
         if (var_scope == nullptr)
             return nullptr;
         if (vars_node != nullptr)
@@ -3044,7 +3209,7 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl
     switch_scope->end_label_name = end_label_name;
     block_scope->node->data.block.name = end_label_name;
 
-    const clang::Expr *cond_expr = stmt->getCond();
+    const ZigClangExpr *cond_expr = bitcast(stmt->getCond());
     assert(cond_expr != nullptr);
 
     AstNode *expr_node = trans_expr(c, ResultUsedYes, &block_scope->base, cond_expr, TransRValue);
@@ -3053,9 +3218,9 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl
     switch_scope->switch_node->data.switch_expr.expr = expr_node;
 
     AstNode *body_node;
-    const clang::Stmt *body_stmt = stmt->getBody();
-    if (body_stmt->getStmtClass() == clang::Stmt::CompoundStmtClass) {
-        if (trans_compound_stmt_inline(c, &switch_scope->base, (const clang::CompoundStmt *)body_stmt,
+    const ZigClangStmt *body_stmt = bitcast(stmt->getBody());
+    if (ZigClangStmt_getStmtClass(body_stmt) == ZigClangStmt_CompoundStmtClass) {
+        if (trans_compound_stmt_inline(c, &switch_scope->base, (const ZigClangCompoundStmt *)body_stmt,
                                        block_scope->node, nullptr))
         {
             return nullptr;
@@ -3092,7 +3257,7 @@ static int trans_switch_case(Context *c, TransScope *parent_scope, const clang::
     *out_node = nullptr;
 
     if (stmt->getRHS() != nullptr) {
-        emit_warning(c, stmt->getBeginLoc(), "TODO support GNU switch case a ... b extension");
+        emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO support GNU switch case a ... b extension");
         return ErrorUnexpected;
     }
 
@@ -3105,7 +3270,7 @@ static int trans_switch_case(Context *c, TransScope *parent_scope, const clang::
     {
         // Add the prong
         AstNode *prong_node = trans_create_node(c, NodeTypeSwitchProng);
-        AstNode *item_node = trans_expr(c, ResultUsedYes, &switch_scope->base, stmt->getLHS(), TransRValue);
+        AstNode *item_node = trans_expr(c, ResultUsedYes, &switch_scope->base, bitcast(stmt->getLHS()), TransRValue);
         if (item_node == nullptr)
             return ErrorUnexpected;
         prong_node->data.switch_prong.items.append(item_node);
@@ -3122,7 +3287,7 @@ static int trans_switch_case(Context *c, TransScope *parent_scope, const clang::
     scope_block->node->data.block.statements.append(case_block);
 
     AstNode *sub_stmt_node;
-    TransScope *new_scope = trans_stmt(c, parent_scope, stmt->getSubStmt(), &sub_stmt_node);
+    TransScope *new_scope = trans_stmt(c, parent_scope, bitcast(stmt->getSubStmt()), &sub_stmt_node);
     if (new_scope == nullptr)
         return ErrorUnexpected;
     if (sub_stmt_node != nullptr)
@@ -3159,7 +3324,7 @@ static int trans_switch_default(Context *c, TransScope *parent_scope, const clan
     scope_block->node->data.block.statements.append(case_block);
 
     AstNode *sub_stmt_node;
-    TransScope *new_scope = trans_stmt(c, parent_scope, stmt->getSubStmt(), &sub_stmt_node);
+    TransScope *new_scope = trans_stmt(c, parent_scope, bitcast(stmt->getSubStmt()), &sub_stmt_node);
     if (new_scope == nullptr)
         return ErrorUnexpected;
     if (sub_stmt_node != nullptr)
@@ -3177,13 +3342,13 @@ static AstNode *trans_string_literal(Context *c, ResultUsed result_used, TransSc
             return maybe_suppress_result(c, result_used, node);
         }
         case clang::StringLiteral::UTF16:
-            emit_warning(c, stmt->getBeginLoc(), "TODO support UTF16 string literals");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO support UTF16 string literals");
             return nullptr;
         case clang::StringLiteral::UTF32:
-            emit_warning(c, stmt->getBeginLoc(), "TODO support UTF32 string literals");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO support UTF32 string literals");
             return nullptr;
         case clang::StringLiteral::Wide:
-            emit_warning(c, stmt->getBeginLoc(), "TODO support wide string literals");
+            emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO support wide string literals");
             return nullptr;
     }
     zig_unreachable();
@@ -3222,45 +3387,45 @@ static int wrap_stmt(AstNode **out_node, TransScope **out_scope, TransScope *in_
     return ErrorNone;
 }
 
-static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *stmt,
+static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *stmt,
         ResultUsed result_used, TransLRValue lrvalue,
         AstNode **out_node, TransScope **out_child_scope,
         TransScope **out_node_scope)
 {
-    clang::Stmt::StmtClass sc = stmt->getStmtClass();
+    ZigClangStmtClass sc = ZigClangStmt_getStmtClass(stmt);
     switch (sc) {
-        case clang::Stmt::ReturnStmtClass:
+        case ZigClangStmt_ReturnStmtClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_return_stmt(c, scope, (const clang::ReturnStmt *)stmt));
-        case clang::Stmt::CompoundStmtClass:
+        case ZigClangStmt_CompoundStmtClass:
             return wrap_stmt(out_node, out_child_scope, scope,
-                    trans_compound_stmt(c, scope, (const clang::CompoundStmt *)stmt, out_node_scope));
-        case clang::Stmt::IntegerLiteralClass:
+                    trans_compound_stmt(c, scope, (const ZigClangCompoundStmt *)stmt, out_node_scope));
+        case ZigClangStmt_IntegerLiteralClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_integer_literal(c, result_used, (const clang::IntegerLiteral *)stmt));
-        case clang::Stmt::ConditionalOperatorClass:
+        case ZigClangStmt_ConditionalOperatorClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_conditional_operator(c, result_used, scope, (const clang::ConditionalOperator *)stmt));
-        case clang::Stmt::BinaryOperatorClass:
+        case ZigClangStmt_BinaryOperatorClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_binary_operator(c, result_used, scope, (const clang::BinaryOperator *)stmt));
-        case clang::Stmt::CompoundAssignOperatorClass:
+        case ZigClangStmt_CompoundAssignOperatorClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_compound_assign_operator(c, result_used, scope, (const clang::CompoundAssignOperator *)stmt));
-        case clang::Stmt::ImplicitCastExprClass:
+        case ZigClangStmt_ImplicitCastExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_implicit_cast_expr(c, result_used, scope, (const clang::ImplicitCastExpr *)stmt));
-        case clang::Stmt::DeclRefExprClass:
+        case ZigClangStmt_DeclRefExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_decl_ref_expr(c, scope, (const clang::DeclRefExpr *)stmt, lrvalue));
-        case clang::Stmt::UnaryOperatorClass:
+        case ZigClangStmt_UnaryOperatorClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_unary_operator(c, result_used, scope, (const clang::UnaryOperator *)stmt));
-        case clang::Stmt::DeclStmtClass:
+        case ZigClangStmt_DeclStmtClass:
             return trans_local_declaration(c, scope, (const clang::DeclStmt *)stmt, out_node, out_child_scope);
-        case clang::Stmt::DoStmtClass:
-        case clang::Stmt::WhileStmtClass: {
-            AstNode *while_node = sc == clang::Stmt::DoStmtClass
+        case ZigClangStmt_DoStmtClass:
+        case ZigClangStmt_WhileStmtClass: {
+            AstNode *while_node = sc == ZigClangStmt_DoStmtClass
                 ? trans_do_loop(c, scope, (const clang::DoStmt *)stmt)
                 : trans_while_loop(c, scope, (const clang::WhileStmt *)stmt);
 
@@ -3273,572 +3438,574 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *st
 
             return wrap_stmt(out_node, out_child_scope, scope, while_node);
         }
-        case clang::Stmt::IfStmtClass:
+        case ZigClangStmt_IfStmtClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_if_statement(c, scope, (const clang::IfStmt *)stmt));
-        case clang::Stmt::CallExprClass:
+        case ZigClangStmt_CallExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_call_expr(c, result_used, scope, (const clang::CallExpr *)stmt));
-        case clang::Stmt::NullStmtClass:
+        case ZigClangStmt_NullStmtClass:
             *out_node = trans_create_node(c, NodeTypeBlock);
             *out_child_scope = scope;
             return ErrorNone;
-        case clang::Stmt::MemberExprClass:
+        case ZigClangStmt_MemberExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_member_expr(c, result_used, scope, (const clang::MemberExpr *)stmt));
-        case clang::Stmt::ArraySubscriptExprClass:
+        case ZigClangStmt_ArraySubscriptExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_array_subscript_expr(c, result_used, scope, (const clang::ArraySubscriptExpr *)stmt));
-        case clang::Stmt::CStyleCastExprClass:
+        case ZigClangStmt_CStyleCastExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_c_style_cast_expr(c, result_used, scope, (const clang::CStyleCastExpr *)stmt, lrvalue));
-        case clang::Stmt::UnaryExprOrTypeTraitExprClass:
+        case ZigClangStmt_UnaryExprOrTypeTraitExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_unary_expr_or_type_trait_expr(c, result_used, scope, (const clang::UnaryExprOrTypeTraitExpr *)stmt));
-        case clang::Stmt::ForStmtClass: {
+        case ZigClangStmt_ForStmtClass: {
             AstNode *node = trans_for_loop(c, scope, (const clang::ForStmt *)stmt);
             return wrap_stmt(out_node, out_child_scope, scope, node);
         }
-        case clang::Stmt::StringLiteralClass:
+        case ZigClangStmt_StringLiteralClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_string_literal(c, result_used, scope, (const clang::StringLiteral *)stmt));
-        case clang::Stmt::BreakStmtClass:
+        case ZigClangStmt_BreakStmtClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_break_stmt(c, scope, (const clang::BreakStmt *)stmt));
-        case clang::Stmt::ContinueStmtClass:
+        case ZigClangStmt_ContinueStmtClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_continue_stmt(c, scope, (const clang::ContinueStmt *)stmt));
-        case clang::Stmt::ParenExprClass:
+        case ZigClangStmt_ParenExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
-                    trans_expr(c, result_used, scope, ((const clang::ParenExpr*)stmt)->getSubExpr(), lrvalue));
-        case clang::Stmt::SwitchStmtClass:
+                    trans_expr(c, result_used, scope,
+                        bitcast(((const clang::ParenExpr*)stmt)->getSubExpr()), lrvalue));
+        case ZigClangStmt_SwitchStmtClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                              trans_switch_stmt(c, scope, (const clang::SwitchStmt *)stmt));
-        case clang::Stmt::CaseStmtClass:
+        case ZigClangStmt_CaseStmtClass:
             return trans_switch_case(c, scope, (const clang::CaseStmt *)stmt, out_node, out_child_scope);
-        case clang::Stmt::DefaultStmtClass:
+        case ZigClangStmt_DefaultStmtClass:
             return trans_switch_default(c, scope, (const clang::DefaultStmt *)stmt, out_node, out_child_scope);
-        case clang::Stmt::ConstantExprClass:
+        case ZigClangStmt_ConstantExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_constant_expr(c, result_used, (const clang::ConstantExpr *)stmt));
-        case clang::Stmt::PredefinedExprClass:
+        case ZigClangStmt_PredefinedExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                              trans_predefined_expr(c, result_used, scope, (const clang::PredefinedExpr *)stmt));
-        case clang::Stmt::StmtExprClass:
+        case ZigClangStmt_StmtExprClass:
             return wrap_stmt(out_node, out_child_scope, scope,
                     trans_stmt_expr(c, result_used, scope, (const clang::StmtExpr *)stmt, out_node_scope));
-        case clang::Stmt::NoStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C NoStmtClass");
-            return ErrorUnexpected;
-        case clang::Stmt::GCCAsmStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C GCCAsmStmtClass");
+        case ZigClangStmt_NoStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C NoStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::MSAsmStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C MSAsmStmtClass");
+        case ZigClangStmt_GCCAsmStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C GCCAsmStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::AttributedStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C AttributedStmtClass");
+        case ZigClangStmt_MSAsmStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MSAsmStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXCatchStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXCatchStmtClass");
+        case ZigClangStmt_AttributedStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C AttributedStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXForRangeStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXForRangeStmtClass");
+        case ZigClangStmt_CXXCatchStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXCatchStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXTryStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXTryStmtClass");
+        case ZigClangStmt_CXXForRangeStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXForRangeStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::CapturedStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CapturedStmtClass");
+        case ZigClangStmt_CXXTryStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXTryStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::CoreturnStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CoreturnStmtClass");
+        case ZigClangStmt_CapturedStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CapturedStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::CoroutineBodyStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CoroutineBodyStmtClass");
+        case ZigClangStmt_CoreturnStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CoreturnStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::BinaryConditionalOperatorClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C BinaryConditionalOperatorClass");
+        case ZigClangStmt_CoroutineBodyStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CoroutineBodyStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::AddrLabelExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C AddrLabelExprClass");
+        case ZigClangStmt_BinaryConditionalOperatorClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C BinaryConditionalOperatorClass");
             return ErrorUnexpected;
-        case clang::Stmt::ArrayInitIndexExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ArrayInitIndexExprClass");
+        case ZigClangStmt_AddrLabelExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C AddrLabelExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ArrayInitLoopExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ArrayInitLoopExprClass");
+        case ZigClangStmt_ArrayInitIndexExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ArrayInitIndexExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ArrayTypeTraitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ArrayTypeTraitExprClass");
+        case ZigClangStmt_ArrayInitLoopExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ArrayInitLoopExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::AsTypeExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C AsTypeExprClass");
+        case ZigClangStmt_ArrayTypeTraitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ArrayTypeTraitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::AtomicExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C AtomicExprClass");
+        case ZigClangStmt_AsTypeExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C AsTypeExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::BlockExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C BlockExprClass");
+        case ZigClangStmt_AtomicExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C AtomicExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXBindTemporaryExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXBindTemporaryExprClass");
+        case ZigClangStmt_BlockExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C BlockExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXBoolLiteralExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXBoolLiteralExprClass");
+        case ZigClangStmt_CXXBindTemporaryExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXBindTemporaryExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXConstructExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXConstructExprClass");
+        case ZigClangStmt_CXXBoolLiteralExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXBoolLiteralExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXTemporaryObjectExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXTemporaryObjectExprClass");
+        case ZigClangStmt_CXXConstructExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXConstructExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXDefaultArgExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXDefaultArgExprClass");
+        case ZigClangStmt_CXXTemporaryObjectExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXTemporaryObjectExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXDefaultInitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXDefaultInitExprClass");
+        case ZigClangStmt_CXXDefaultArgExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDefaultArgExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXDeleteExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXDeleteExprClass");
+        case ZigClangStmt_CXXDefaultInitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDefaultInitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXDependentScopeMemberExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXDependentScopeMemberExprClass");
+        case ZigClangStmt_CXXDeleteExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDeleteExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXFoldExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXFoldExprClass");
+        case ZigClangStmt_CXXDependentScopeMemberExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDependentScopeMemberExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXInheritedCtorInitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXInheritedCtorInitExprClass");
+        case ZigClangStmt_CXXFoldExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXFoldExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXNewExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXNewExprClass");
+        case ZigClangStmt_CXXInheritedCtorInitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXInheritedCtorInitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXNoexceptExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXNoexceptExprClass");
+        case ZigClangStmt_CXXNewExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXNewExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXNullPtrLiteralExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXNullPtrLiteralExprClass");
+        case ZigClangStmt_CXXNoexceptExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXNoexceptExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXPseudoDestructorExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXPseudoDestructorExprClass");
+        case ZigClangStmt_CXXNullPtrLiteralExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXNullPtrLiteralExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXScalarValueInitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXScalarValueInitExprClass");
+        case ZigClangStmt_CXXPseudoDestructorExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXPseudoDestructorExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXStdInitializerListExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXStdInitializerListExprClass");
+        case ZigClangStmt_CXXScalarValueInitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXScalarValueInitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXThisExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXThisExprClass");
+        case ZigClangStmt_CXXStdInitializerListExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXStdInitializerListExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXThrowExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXThrowExprClass");
+        case ZigClangStmt_CXXThisExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXThisExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXTypeidExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXTypeidExprClass");
+        case ZigClangStmt_CXXThrowExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXThrowExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXUnresolvedConstructExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXUnresolvedConstructExprClass");
+        case ZigClangStmt_CXXTypeidExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXTypeidExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXUuidofExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXUuidofExprClass");
+        case ZigClangStmt_CXXUnresolvedConstructExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXUnresolvedConstructExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CUDAKernelCallExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CUDAKernelCallExprClass");
+        case ZigClangStmt_CXXUuidofExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXUuidofExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXMemberCallExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXMemberCallExprClass");
+        case ZigClangStmt_CUDAKernelCallExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CUDAKernelCallExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXOperatorCallExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXOperatorCallExprClass");
+        case ZigClangStmt_CXXMemberCallExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXMemberCallExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::UserDefinedLiteralClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C UserDefinedLiteralClass");
+        case ZigClangStmt_CXXOperatorCallExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXOperatorCallExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXFunctionalCastExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXFunctionalCastExprClass");
+        case ZigClangStmt_UserDefinedLiteralClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C UserDefinedLiteralClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXConstCastExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXConstCastExprClass");
+        case ZigClangStmt_CXXFunctionalCastExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXFunctionalCastExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXDynamicCastExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXDynamicCastExprClass");
+        case ZigClangStmt_CXXConstCastExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXConstCastExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXReinterpretCastExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXReinterpretCastExprClass");
+        case ZigClangStmt_CXXDynamicCastExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDynamicCastExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CXXStaticCastExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CXXStaticCastExprClass");
+        case ZigClangStmt_CXXReinterpretCastExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXReinterpretCastExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCBridgedCastExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCBridgedCastExprClass");
+        case ZigClangStmt_CXXStaticCastExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXStaticCastExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CharacterLiteralClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CharacterLiteralClass");
+        case ZigClangStmt_ObjCBridgedCastExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCBridgedCastExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ChooseExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ChooseExprClass");
+        case ZigClangStmt_CharacterLiteralClass:
+            return wrap_stmt(out_node, out_child_scope, scope,
+                    trans_character_literal(c, result_used, (const clang::CharacterLiteral *)stmt));
             return ErrorUnexpected;
-        case clang::Stmt::CompoundLiteralExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CompoundLiteralExprClass");
+        case ZigClangStmt_ChooseExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ChooseExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ConvertVectorExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ConvertVectorExprClass");
+        case ZigClangStmt_CompoundLiteralExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CompoundLiteralExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CoawaitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CoawaitExprClass");
+        case ZigClangStmt_ConvertVectorExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ConvertVectorExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::CoyieldExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C CoyieldExprClass");
+        case ZigClangStmt_CoawaitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CoawaitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::DependentCoawaitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C DependentCoawaitExprClass");
+        case ZigClangStmt_CoyieldExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CoyieldExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::DependentScopeDeclRefExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C DependentScopeDeclRefExprClass");
+        case ZigClangStmt_DependentCoawaitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C DependentCoawaitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::DesignatedInitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C DesignatedInitExprClass");
+        case ZigClangStmt_DependentScopeDeclRefExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C DependentScopeDeclRefExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::DesignatedInitUpdateExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C DesignatedInitUpdateExprClass");
+        case ZigClangStmt_DesignatedInitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C DesignatedInitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ExpressionTraitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ExpressionTraitExprClass");
+        case ZigClangStmt_DesignatedInitUpdateExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C DesignatedInitUpdateExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ExtVectorElementExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ExtVectorElementExprClass");
+        case ZigClangStmt_ExpressionTraitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ExpressionTraitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::FixedPointLiteralClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C FixedPointLiteralClass");
+        case ZigClangStmt_ExtVectorElementExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ExtVectorElementExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::FloatingLiteralClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C FloatingLiteralClass");
+        case ZigClangStmt_FixedPointLiteralClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C FixedPointLiteralClass");
             return ErrorUnexpected;
-        case clang::Stmt::ExprWithCleanupsClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ExprWithCleanupsClass");
+        case ZigClangStmt_FloatingLiteralClass:
+            return wrap_stmt(out_node, out_child_scope, scope,
+                    trans_floating_literal(c, result_used, (const clang::FloatingLiteral *)stmt));
+        case ZigClangStmt_ExprWithCleanupsClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ExprWithCleanupsClass");
             return ErrorUnexpected;
-        case clang::Stmt::FunctionParmPackExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C FunctionParmPackExprClass");
+        case ZigClangStmt_FunctionParmPackExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C FunctionParmPackExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::GNUNullExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C GNUNullExprClass");
+        case ZigClangStmt_GNUNullExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C GNUNullExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::GenericSelectionExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C GenericSelectionExprClass");
+        case ZigClangStmt_GenericSelectionExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C GenericSelectionExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ImaginaryLiteralClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ImaginaryLiteralClass");
+        case ZigClangStmt_ImaginaryLiteralClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ImaginaryLiteralClass");
             return ErrorUnexpected;
-        case clang::Stmt::ImplicitValueInitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ImplicitValueInitExprClass");
+        case ZigClangStmt_ImplicitValueInitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ImplicitValueInitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::InitListExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C InitListExprClass");
+        case ZigClangStmt_InitListExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C InitListExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::LambdaExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C LambdaExprClass");
+        case ZigClangStmt_LambdaExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C LambdaExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::MSPropertyRefExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C MSPropertyRefExprClass");
+        case ZigClangStmt_MSPropertyRefExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MSPropertyRefExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::MSPropertySubscriptExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C MSPropertySubscriptExprClass");
+        case ZigClangStmt_MSPropertySubscriptExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MSPropertySubscriptExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::MaterializeTemporaryExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C MaterializeTemporaryExprClass");
+        case ZigClangStmt_MaterializeTemporaryExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MaterializeTemporaryExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::NoInitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C NoInitExprClass");
+        case ZigClangStmt_NoInitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C NoInitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPArraySectionExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPArraySectionExprClass");
+        case ZigClangStmt_OMPArraySectionExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPArraySectionExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCArrayLiteralClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCArrayLiteralClass");
+        case ZigClangStmt_ObjCArrayLiteralClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCArrayLiteralClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCAvailabilityCheckExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCAvailabilityCheckExprClass");
+        case ZigClangStmt_ObjCAvailabilityCheckExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAvailabilityCheckExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCBoolLiteralExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCBoolLiteralExprClass");
+        case ZigClangStmt_ObjCBoolLiteralExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCBoolLiteralExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCBoxedExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCBoxedExprClass");
+        case ZigClangStmt_ObjCBoxedExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCBoxedExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCDictionaryLiteralClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCDictionaryLiteralClass");
+        case ZigClangStmt_ObjCDictionaryLiteralClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCDictionaryLiteralClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCEncodeExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCEncodeExprClass");
+        case ZigClangStmt_ObjCEncodeExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCEncodeExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCIndirectCopyRestoreExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCIndirectCopyRestoreExprClass");
+        case ZigClangStmt_ObjCIndirectCopyRestoreExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCIndirectCopyRestoreExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCIsaExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCIsaExprClass");
+        case ZigClangStmt_ObjCIsaExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCIsaExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCIvarRefExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCIvarRefExprClass");
+        case ZigClangStmt_ObjCIvarRefExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCIvarRefExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCMessageExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCMessageExprClass");
+        case ZigClangStmt_ObjCMessageExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCMessageExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCPropertyRefExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCPropertyRefExprClass");
+        case ZigClangStmt_ObjCPropertyRefExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCPropertyRefExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCProtocolExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCProtocolExprClass");
+        case ZigClangStmt_ObjCProtocolExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCProtocolExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCSelectorExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCSelectorExprClass");
+        case ZigClangStmt_ObjCSelectorExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCSelectorExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCStringLiteralClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCStringLiteralClass");
+        case ZigClangStmt_ObjCStringLiteralClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCStringLiteralClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCSubscriptRefExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCSubscriptRefExprClass");
+        case ZigClangStmt_ObjCSubscriptRefExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCSubscriptRefExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::OffsetOfExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OffsetOfExprClass");
+        case ZigClangStmt_OffsetOfExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OffsetOfExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::OpaqueValueExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OpaqueValueExprClass");
+        case ZigClangStmt_OpaqueValueExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OpaqueValueExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::UnresolvedLookupExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C UnresolvedLookupExprClass");
+        case ZigClangStmt_UnresolvedLookupExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C UnresolvedLookupExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::UnresolvedMemberExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C UnresolvedMemberExprClass");
+        case ZigClangStmt_UnresolvedMemberExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C UnresolvedMemberExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::PackExpansionExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C PackExpansionExprClass");
+        case ZigClangStmt_PackExpansionExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C PackExpansionExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ParenListExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ParenListExprClass");
+        case ZigClangStmt_ParenListExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ParenListExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::PseudoObjectExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C PseudoObjectExprClass");
+        case ZigClangStmt_PseudoObjectExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C PseudoObjectExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::ShuffleVectorExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ShuffleVectorExprClass");
+        case ZigClangStmt_ShuffleVectorExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ShuffleVectorExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::SizeOfPackExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C SizeOfPackExprClass");
+        case ZigClangStmt_SizeOfPackExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SizeOfPackExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::SubstNonTypeTemplateParmExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C SubstNonTypeTemplateParmExprClass");
+        case ZigClangStmt_SubstNonTypeTemplateParmExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SubstNonTypeTemplateParmExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::SubstNonTypeTemplateParmPackExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C SubstNonTypeTemplateParmPackExprClass");
+        case ZigClangStmt_SubstNonTypeTemplateParmPackExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SubstNonTypeTemplateParmPackExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::TypeTraitExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C TypeTraitExprClass");
+        case ZigClangStmt_TypeTraitExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C TypeTraitExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::TypoExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C TypoExprClass");
+        case ZigClangStmt_TypoExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C TypoExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::VAArgExprClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C VAArgExprClass");
+        case ZigClangStmt_VAArgExprClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C VAArgExprClass");
             return ErrorUnexpected;
-        case clang::Stmt::GotoStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C GotoStmtClass");
+        case ZigClangStmt_GotoStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C GotoStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::IndirectGotoStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C IndirectGotoStmtClass");
+        case ZigClangStmt_IndirectGotoStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C IndirectGotoStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::LabelStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C LabelStmtClass");
+        case ZigClangStmt_LabelStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C LabelStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::MSDependentExistsStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C MSDependentExistsStmtClass");
+        case ZigClangStmt_MSDependentExistsStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MSDependentExistsStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPAtomicDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPAtomicDirectiveClass");
+        case ZigClangStmt_OMPAtomicDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPAtomicDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPBarrierDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPBarrierDirectiveClass");
+        case ZigClangStmt_OMPBarrierDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPBarrierDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPCancelDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPCancelDirectiveClass");
+        case ZigClangStmt_OMPCancelDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPCancelDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPCancellationPointDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPCancellationPointDirectiveClass");
+        case ZigClangStmt_OMPCancellationPointDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPCancellationPointDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPCriticalDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPCriticalDirectiveClass");
+        case ZigClangStmt_OMPCriticalDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPCriticalDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPFlushDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPFlushDirectiveClass");
+        case ZigClangStmt_OMPFlushDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPFlushDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPDistributeDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPDistributeDirectiveClass");
+        case ZigClangStmt_OMPDistributeDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPDistributeDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPDistributeParallelForDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPDistributeParallelForDirectiveClass");
+        case ZigClangStmt_OMPDistributeParallelForDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPDistributeParallelForDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPDistributeParallelForSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPDistributeParallelForSimdDirectiveClass");
+        case ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPDistributeParallelForSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPDistributeSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPDistributeSimdDirectiveClass");
+        case ZigClangStmt_OMPDistributeSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPDistributeSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPForDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPForDirectiveClass");
+        case ZigClangStmt_OMPForDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPForDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPForSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPForSimdDirectiveClass");
+        case ZigClangStmt_OMPForSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPForSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPParallelForDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPParallelForDirectiveClass");
+        case ZigClangStmt_OMPParallelForDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPParallelForDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPParallelForSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPParallelForSimdDirectiveClass");
+        case ZigClangStmt_OMPParallelForSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPParallelForSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPSimdDirectiveClass");
+        case ZigClangStmt_OMPSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetParallelForSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetParallelForSimdDirectiveClass");
+        case ZigClangStmt_OMPTargetParallelForSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetParallelForSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetSimdDirectiveClass");
+        case ZigClangStmt_OMPTargetSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetTeamsDistributeDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetTeamsDistributeDirectiveClass");
+        case ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDistributeDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetTeamsDistributeParallelForDirectiveClass");
+        case ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDistributeParallelForDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetTeamsDistributeParallelForSimdDirectiveClass");
+        case ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDistributeParallelForSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetTeamsDistributeSimdDirectiveClass");
+        case ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDistributeSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTaskLoopDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTaskLoopDirectiveClass");
+        case ZigClangStmt_OMPTaskLoopDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskLoopDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTaskLoopSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTaskLoopSimdDirectiveClass");
+        case ZigClangStmt_OMPTaskLoopSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskLoopSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTeamsDistributeDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTeamsDistributeDirectiveClass");
+        case ZigClangStmt_OMPTeamsDistributeDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDistributeDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTeamsDistributeParallelForDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTeamsDistributeParallelForDirectiveClass");
+        case ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDistributeParallelForDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTeamsDistributeParallelForSimdDirectiveClass");
+        case ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDistributeParallelForSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTeamsDistributeSimdDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTeamsDistributeSimdDirectiveClass");
+        case ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDistributeSimdDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPMasterDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPMasterDirectiveClass");
+        case ZigClangStmt_OMPMasterDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPMasterDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPOrderedDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPOrderedDirectiveClass");
+        case ZigClangStmt_OMPOrderedDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPOrderedDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPParallelDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPParallelDirectiveClass");
+        case ZigClangStmt_OMPParallelDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPParallelDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPParallelSectionsDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPParallelSectionsDirectiveClass");
+        case ZigClangStmt_OMPParallelSectionsDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPParallelSectionsDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPSectionDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPSectionDirectiveClass");
+        case ZigClangStmt_OMPSectionDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPSectionDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPSectionsDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPSectionsDirectiveClass");
+        case ZigClangStmt_OMPSectionsDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPSectionsDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPSingleDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPSingleDirectiveClass");
+        case ZigClangStmt_OMPSingleDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPSingleDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetDataDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetDataDirectiveClass");
+        case ZigClangStmt_OMPTargetDataDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetDataDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetDirectiveClass");
+        case ZigClangStmt_OMPTargetDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetEnterDataDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetEnterDataDirectiveClass");
+        case ZigClangStmt_OMPTargetEnterDataDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetEnterDataDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetExitDataDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetExitDataDirectiveClass");
+        case ZigClangStmt_OMPTargetExitDataDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetExitDataDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetParallelDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetParallelDirectiveClass");
+        case ZigClangStmt_OMPTargetParallelDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetParallelDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetParallelForDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetParallelForDirectiveClass");
+        case ZigClangStmt_OMPTargetParallelForDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetParallelForDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetTeamsDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetTeamsDirectiveClass");
+        case ZigClangStmt_OMPTargetTeamsDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTargetUpdateDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTargetUpdateDirectiveClass");
+        case ZigClangStmt_OMPTargetUpdateDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetUpdateDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTaskDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTaskDirectiveClass");
+        case ZigClangStmt_OMPTaskDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTaskgroupDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTaskgroupDirectiveClass");
+        case ZigClangStmt_OMPTaskgroupDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskgroupDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTaskwaitDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTaskwaitDirectiveClass");
+        case ZigClangStmt_OMPTaskwaitDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskwaitDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTaskyieldDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTaskyieldDirectiveClass");
+        case ZigClangStmt_OMPTaskyieldDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskyieldDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::OMPTeamsDirectiveClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C OMPTeamsDirectiveClass");
+        case ZigClangStmt_OMPTeamsDirectiveClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDirectiveClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCAtCatchStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCAtCatchStmtClass");
+        case ZigClangStmt_ObjCAtCatchStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtCatchStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCAtFinallyStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCAtFinallyStmtClass");
+        case ZigClangStmt_ObjCAtFinallyStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtFinallyStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCAtSynchronizedStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCAtSynchronizedStmtClass");
+        case ZigClangStmt_ObjCAtSynchronizedStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtSynchronizedStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCAtThrowStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCAtThrowStmtClass");
+        case ZigClangStmt_ObjCAtThrowStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtThrowStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCAtTryStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCAtTryStmtClass");
+        case ZigClangStmt_ObjCAtTryStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtTryStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCAutoreleasePoolStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCAutoreleasePoolStmtClass");
+        case ZigClangStmt_ObjCAutoreleasePoolStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAutoreleasePoolStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::ObjCForCollectionStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C ObjCForCollectionStmtClass");
+        case ZigClangStmt_ObjCForCollectionStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCForCollectionStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::SEHExceptStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C SEHExceptStmtClass");
+        case ZigClangStmt_SEHExceptStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHExceptStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::SEHFinallyStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C SEHFinallyStmtClass");
+        case ZigClangStmt_SEHFinallyStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHFinallyStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::SEHLeaveStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C SEHLeaveStmtClass");
+        case ZigClangStmt_SEHLeaveStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHLeaveStmtClass");
             return ErrorUnexpected;
-        case clang::Stmt::SEHTryStmtClass:
-            emit_warning(c, stmt->getBeginLoc(), "TODO handle C SEHTryStmtClass");
+        case ZigClangStmt_SEHTryStmtClass:
+            emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHTryStmtClass");
             return ErrorUnexpected;
     }
     zig_unreachable();
 }
 
 // Returns null if there was an error
-static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr,
+static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr,
         TransLRValue lrval)
 {
     AstNode *result_node;
     TransScope *result_scope;
-    if (trans_stmt_extra(c, scope, expr, result_used, lrval, &result_node, &result_scope, nullptr)) {
+    if (trans_stmt_extra(c, scope, (const ZigClangStmt *)expr, result_used, lrval, &result_node, &result_scope, nullptr)) {
         return nullptr;
     }
     return result_node;
@@ -3846,7 +4013,7 @@ static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope
 
 // Statements have no result and no concept of L or R value.
 // Returns child scope, or null if there was an error
-static TransScope *trans_stmt(Context *c, TransScope *scope, const clang::Stmt *stmt, AstNode **out_node) {
+static TransScope *trans_stmt(Context *c, TransScope *scope, const ZigClangStmt *stmt, AstNode **out_node) {
     TransScope *child_scope;
     if (trans_stmt_extra(c, scope, stmt, ResultUsedNo, TransRValue, out_node, &child_scope, nullptr)) {
         return nullptr;
@@ -3854,34 +4021,36 @@ static TransScope *trans_stmt(Context *c, TransScope *scope, const clang::Stmt *
     return child_scope;
 }
 
-static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) {
-    Buf *fn_name = buf_create_from_str(decl_name(fn_decl));
+static void visit_fn_decl(Context *c, const ZigClangFunctionDecl *fn_decl) {
+    Buf *fn_name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)fn_decl));
 
     if (get_global(c, fn_name)) {
         // we already saw this function
         return;
     }
 
-    AstNode *proto_node = trans_qual_type(c, fn_decl->getType(), fn_decl->getLocation());
+    AstNode *proto_node = trans_qual_type(c, ZigClangFunctionDecl_getType(fn_decl),
+            ZigClangFunctionDecl_getLocation(fn_decl));
     if (proto_node == nullptr) {
-        emit_warning(c, fn_decl->getLocation(), "unable to resolve prototype of function '%s'", buf_ptr(fn_name));
+        emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl),
+                "unable to resolve prototype of function '%s'", buf_ptr(fn_name));
         return;
     }
 
     proto_node->data.fn_proto.name = fn_name;
-    proto_node->data.fn_proto.is_extern = !fn_decl->hasBody();
+    proto_node->data.fn_proto.is_extern = !ZigClangFunctionDecl_hasBody(fn_decl);
 
-    clang::StorageClass sc = fn_decl->getStorageClass();
-    if (sc == clang::SC_None) {
+    ZigClangStorageClass sc = ZigClangFunctionDecl_getStorageClass(fn_decl);
+    if (sc == ZigClangStorageClass_None) {
         proto_node->data.fn_proto.visib_mod = c->visib_mod;
-        proto_node->data.fn_proto.is_export = fn_decl->hasBody() ? c->want_export : false;
-    } else if (sc == clang::SC_Extern || sc == clang::SC_Static) {
+        proto_node->data.fn_proto.is_export = ZigClangFunctionDecl_hasBody(fn_decl) ? c->want_export : false;
+    } else if (sc == ZigClangStorageClass_Extern || sc == ZigClangStorageClass_Static) {
         proto_node->data.fn_proto.visib_mod = c->visib_mod;
-    } else if (sc == clang::SC_PrivateExtern) {
-        emit_warning(c, fn_decl->getLocation(), "unsupported storage class: private extern");
+    } else if (sc == ZigClangStorageClass_PrivateExtern) {
+        emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl), "unsupported storage class: private extern");
         return;
     } else {
-        emit_warning(c, fn_decl->getLocation(), "unsupported storage class: unknown");
+        emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl), "unsupported storage class: unknown");
         return;
     }
 
@@ -3889,8 +4058,8 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) {
 
     for (size_t i = 0; i < proto_node->data.fn_proto.params.length; i += 1) {
         AstNode *param_node = proto_node->data.fn_proto.params.at(i);
-        const clang::ParmVarDecl *param = fn_decl->getParamDecl(i);
-        const char *name = decl_name(param);
+        const ZigClangParmVarDecl *param = ZigClangFunctionDecl_getParamDecl(fn_decl, i);
+        const char *name = ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)param);
 
         Buf *proto_param_name;
         if (strlen(name) != 0) {
@@ -3908,7 +4077,7 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) {
         param_node->data.param_decl.name = scope_var->zig_name;
     }
 
-    if (!fn_decl->hasBody()) {
+    if (!ZigClangFunctionDecl_hasBody(fn_decl)) {
         // just a prototype
         add_top_level_decl(c, proto_node->data.fn_proto.name, proto_node);
         return;
@@ -3916,11 +4085,11 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) {
 
     // actual function definition with body
     c->ptr_params.clear();
-    clang::Stmt *body = fn_decl->getBody();
+    const ZigClangStmt *body = ZigClangFunctionDecl_getBody(fn_decl);
     AstNode *actual_body_node;
     TransScope *result_scope = trans_stmt(c, scope, body, &actual_body_node);
     if (result_scope == nullptr) {
-        emit_warning(c, fn_decl->getLocation(), "unable to translate function");
+        emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl), "unable to translate function");
         return;
     }
     assert(actual_body_node != nullptr);
@@ -3958,20 +4127,20 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) {
     add_top_level_decl(c, fn_def_node->data.fn_def.fn_proto->data.fn_proto.name, fn_def_node);
 }
 
-static AstNode *resolve_typdef_as_builtin(Context *c, const clang::TypedefNameDecl *typedef_decl, const char *primitive_name) {
+static AstNode *resolve_typdef_as_builtin(Context *c, const ZigClangTypedefNameDecl *typedef_decl, const char *primitive_name) {
     AstNode *node = trans_create_node_symbol_str(c, primitive_name);
     c->decl_table.put(typedef_decl, node);
     return node;
 }
 
-static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *typedef_decl) {
-    auto existing_entry = c->decl_table.maybe_get((void*)typedef_decl->getCanonicalDecl());
+static AstNode *resolve_typedef_decl(Context *c, const ZigClangTypedefNameDecl *typedef_decl) {
+    auto existing_entry = c->decl_table.maybe_get((void*)ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl));
     if (existing_entry) {
         return existing_entry->value;
     }
 
-    clang::QualType child_qt = typedef_decl->getUnderlyingType();
-    Buf *type_name = buf_create_from_str(decl_name(typedef_decl));
+    ZigClangQualType child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
+    Buf *type_name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)typedef_decl));
 
     if (buf_eql_str(type_name, "uint8_t")) {
         return resolve_typdef_as_builtin(c, typedef_decl, "u8");
@@ -4005,11 +4174,12 @@ static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *t
 
     // trans_qual_type here might cause us to look at this typedef again so we put the item in the map first
     AstNode *symbol_node = trans_create_node_symbol(c, type_name);
-    c->decl_table.put(typedef_decl->getCanonicalDecl(), symbol_node);
+    c->decl_table.put(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl), symbol_node);
 
-    AstNode *type_node = trans_qual_type(c, child_qt, typedef_decl->getLocation());
+    AstNode *type_node = trans_qual_type(c, child_qt, ZigClangTypedefNameDecl_getLocation(typedef_decl));
     if (type_node == nullptr) {
-        emit_warning(c, typedef_decl->getLocation(), "typedef %s - unresolved child type", buf_ptr(type_name));
+        emit_warning(c, ZigClangTypedefNameDecl_getLocation(typedef_decl),
+                "typedef %s - unresolved child type", buf_ptr(type_name));
         c->decl_table.put(typedef_decl, nullptr);
         // TODO add global var with type_name equal to @compileError("unable to resolve C type") 
         return nullptr;
@@ -4019,33 +4189,33 @@ static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *t
     return symbol_node;
 }
 
-struct AstNode *demote_enum_to_opaque(Context *c, const clang::EnumDecl *enum_decl,
-        Buf *full_type_name, Buf *bare_name)
+struct AstNode *demote_enum_to_opaque(Context *c, const ZigClangEnumDecl *enum_decl, Buf *full_type_name,
+        Buf *bare_name)
 {
     AstNode *opaque_node = trans_create_node_opaque(c);
     if (full_type_name == nullptr) {
-        c->decl_table.put(enum_decl->getCanonicalDecl(), opaque_node);
+        c->decl_table.put(ZigClangEnumDecl_getCanonicalDecl(enum_decl), opaque_node);
         return opaque_node;
     }
     AstNode *symbol_node = trans_create_node_symbol(c, full_type_name);
     add_global_weak_alias(c, bare_name, full_type_name);
     add_global_var(c, full_type_name, opaque_node);
-    c->decl_table.put(enum_decl->getCanonicalDecl(), symbol_node);
+    c->decl_table.put(ZigClangEnumDecl_getCanonicalDecl(enum_decl), symbol_node);
     return symbol_node;
 }
 
-static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl) {
-    auto existing_entry = c->decl_table.maybe_get((void*)enum_decl->getCanonicalDecl());
+static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl) {
+    auto existing_entry = c->decl_table.maybe_get(ZigClangEnumDecl_getCanonicalDecl(enum_decl));
     if (existing_entry) {
         return existing_entry->value;
     }
 
-    const char *raw_name = decl_name(enum_decl);
+    const char *raw_name = ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)enum_decl);
     bool is_anonymous = (raw_name[0] == 0);
     Buf *bare_name = is_anonymous ? nullptr : buf_create_from_str(raw_name);
     Buf *full_type_name = is_anonymous ? nullptr : buf_sprintf("enum_%s", buf_ptr(bare_name));
 
-    const clang::EnumDecl *enum_def = enum_decl->getDefinition();
+    const ZigClangEnumDecl *enum_def = ZigClangEnumDecl_getDefinition(enum_decl);
     if (!enum_def) {
         return demote_enum_to_opaque(c, enum_decl, full_type_name, bare_name);
     }
@@ -4053,8 +4223,8 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl)
 
     bool pure_enum = true;
     uint32_t field_count = 0;
-    for (auto it = enum_def->enumerator_begin(),
-              it_end = enum_def->enumerator_end();
+    for (auto it = reinterpret_cast<const clang::EnumDecl *>(enum_def)->enumerator_begin(),
+              it_end = reinterpret_cast<const clang::EnumDecl *>(enum_def)->enumerator_end();
               it != it_end; ++it, field_count += 1)
     {
         const clang::EnumConstantDecl *enum_const = *it;
@@ -4062,7 +4232,8 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl)
             pure_enum = false;
         }
     }
-    AstNode *tag_int_type = trans_qual_type(c, enum_decl->getIntegerType(), enum_decl->getLocation());
+    AstNode *tag_int_type = trans_qual_type(c, ZigClangEnumDecl_getIntegerType(enum_decl),
+            ZigClangEnumDecl_getLocation(enum_decl));
     assert(tag_int_type);
 
     AstNode *enum_node = trans_create_node(c, NodeTypeContainerDecl);
@@ -4071,20 +4242,20 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl)
     // TODO only emit this tag type if the enum tag type is not the default.
     // I don't know what the default is, need to figure out how clang is deciding.
     // it appears to at least be different across gcc/msvc
-    if (!c_is_builtin_type(c, enum_decl->getIntegerType(), clang::BuiltinType::UInt) &&
-        !c_is_builtin_type(c, enum_decl->getIntegerType(), clang::BuiltinType::Int))
+    if (!c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), ZigClangBuiltinTypeUInt) &&
+        !c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), ZigClangBuiltinTypeInt))
     {
         enum_node->data.container_decl.init_arg_expr = tag_int_type;
     }
     enum_node->data.container_decl.fields.resize(field_count);
     uint32_t i = 0;
-    for (auto it = enum_def->enumerator_begin(),
-            it_end = enum_def->enumerator_end();
+    for (auto it = reinterpret_cast<const clang::EnumDecl *>(enum_def)->enumerator_begin(),
+            it_end = reinterpret_cast<const clang::EnumDecl *>(enum_def)->enumerator_end();
             it != it_end; ++it, i += 1)
     {
         const clang::EnumConstantDecl *enum_const = *it;
 
-        Buf *enum_val_name = buf_create_from_str(decl_name(enum_const));
+        Buf *enum_val_name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)enum_const));
         Buf *field_name;
         if (bare_name != nullptr && buf_starts_with_buf(enum_val_name, bare_name)) {
             field_name = buf_slice(enum_val_name, buf_len(bare_name), buf_len(enum_val_name));
@@ -4092,7 +4263,8 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl)
             field_name = enum_val_name;
         }
 
-        AstNode *int_node = pure_enum && !is_anonymous ? nullptr : trans_create_node_apint(c, enum_const->getInitVal());
+        AstNode *int_node = pure_enum && !is_anonymous ?
+            nullptr : trans_create_node_apint(c, bitcast(&enum_const->getInitVal()));
         AstNode *field_node = trans_create_node(c, NodeTypeStructField);
         field_node->data.struct_field.name = field_name;
         field_node->data.struct_field.type = nullptr;
@@ -4102,7 +4274,7 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl)
         // in C each enum value is in the global namespace. so we put them there too.
         // at this point we can rely on the enum emitting successfully
         if (is_anonymous) {
-            Buf *enum_val_name = buf_create_from_str(decl_name(enum_const));
+            Buf *enum_val_name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)enum_const));
             add_global_var(c, enum_val_name, int_node);
         } else {
             AstNode *field_access_node = trans_create_node_field_access(c,
@@ -4112,73 +4284,74 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl)
     }
 
     if (is_anonymous) {
-        c->decl_table.put(enum_decl->getCanonicalDecl(), enum_node);
+        c->decl_table.put(ZigClangEnumDecl_getCanonicalDecl(enum_decl), enum_node);
         return enum_node;
     } else {
         AstNode *symbol_node = trans_create_node_symbol(c, full_type_name);
         add_global_weak_alias(c, bare_name, full_type_name);
         add_global_var(c, full_type_name, enum_node);
-        c->decl_table.put(enum_decl->getCanonicalDecl(), symbol_node);
+        c->decl_table.put(ZigClangEnumDecl_getCanonicalDecl(enum_decl), symbol_node);
         return enum_node;
     }
 }
 
-static AstNode *demote_struct_to_opaque(Context *c, const clang::RecordDecl *record_decl,
+static AstNode *demote_struct_to_opaque(Context *c, const ZigClangRecordDecl *record_decl,
         Buf *full_type_name, Buf *bare_name)
 {
     AstNode *opaque_node = trans_create_node_opaque(c);
     if (full_type_name == nullptr) {
-        c->decl_table.put(record_decl->getCanonicalDecl(), opaque_node);
+        c->decl_table.put(ZigClangRecordDecl_getCanonicalDecl(record_decl), opaque_node);
         return opaque_node;
     }
     AstNode *symbol_node = trans_create_node_symbol(c, full_type_name);
     add_global_weak_alias(c, bare_name, full_type_name);
     add_global_var(c, full_type_name, opaque_node);
-    c->decl_table.put(record_decl->getCanonicalDecl(), symbol_node);
+    c->decl_table.put(ZigClangRecordDecl_getCanonicalDecl(record_decl), symbol_node);
     return symbol_node;
 }
 
-static AstNode *resolve_record_decl(Context *c, const clang::RecordDecl *record_decl) {
-    auto existing_entry = c->decl_table.maybe_get((void*)record_decl->getCanonicalDecl());
+static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record_decl) {
+    auto existing_entry = c->decl_table.maybe_get(ZigClangRecordDecl_getCanonicalDecl(record_decl));
     if (existing_entry) {
         return existing_entry->value;
     }
 
-    const char *raw_name = decl_name(record_decl);
+    const char *raw_name = ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)record_decl);
     const char *container_kind_name;
     ContainerKind container_kind;
-    if (record_decl->isUnion()) {
+    if (ZigClangRecordDecl_isUnion(record_decl)) {
         container_kind_name = "union";
         container_kind = ContainerKindUnion;
-    } else if (record_decl->isStruct()) {
+    } else if (ZigClangRecordDecl_isStruct(record_decl)) {
         container_kind_name = "struct";
         container_kind = ContainerKindStruct;
     } else {
-        emit_warning(c, record_decl->getLocation(), "skipping record %s, not a struct or union", raw_name);
-        c->decl_table.put(record_decl->getCanonicalDecl(), nullptr);
+        emit_warning(c, ZigClangRecordDecl_getLocation(record_decl),
+                "skipping record %s, not a struct or union", raw_name);
+        c->decl_table.put(ZigClangRecordDecl_getCanonicalDecl(record_decl), nullptr);
         return nullptr;
     }
 
-    bool is_anonymous = record_decl->isAnonymousStructOrUnion() || raw_name[0] == 0;
+    bool is_anonymous = ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl) || raw_name[0] == 0;
     Buf *bare_name = is_anonymous ? nullptr : buf_create_from_str(raw_name);
     Buf *full_type_name = (bare_name == nullptr) ?
         nullptr : buf_sprintf("%s_%s", container_kind_name, buf_ptr(bare_name));
 
-    clang::RecordDecl *record_def = record_decl->getDefinition();
+    const ZigClangRecordDecl *record_def = ZigClangRecordDecl_getDefinition(record_decl);
     if (record_def == nullptr) {
         return demote_struct_to_opaque(c, record_decl, full_type_name, bare_name);
     }
 
     // count fields and validate
     uint32_t field_count = 0;
-    for (auto it = record_def->field_begin(),
-              it_end = record_def->field_end();
+    for (auto it = reinterpret_cast<const clang::RecordDecl *>(record_def)->field_begin(),
+              it_end = reinterpret_cast<const clang::RecordDecl *>(record_def)->field_end();
               it != it_end; ++it, field_count += 1)
     {
         const clang::FieldDecl *field_decl = *it;
 
         if (field_decl->isBitField()) {
-            emit_warning(c, field_decl->getLocation(), "%s %s demoted to opaque type - has bitfield",
+            emit_warning(c, bitcast(field_decl->getLocation()), "%s %s demoted to opaque type - has bitfield",
                     container_kind_name,
                     is_anonymous ? "(anon)" : buf_ptr(bare_name));
             return demote_struct_to_opaque(c, record_decl, full_type_name, bare_name);
@@ -4195,24 +4368,25 @@ static AstNode *resolve_record_decl(Context *c, const clang::RecordDecl *record_
 
     // must be before fields in case a circular reference happens
     if (is_anonymous) {
-        c->decl_table.put(record_decl->getCanonicalDecl(), struct_node);
+        c->decl_table.put(ZigClangRecordDecl_getCanonicalDecl(record_decl), struct_node);
     } else {
-        c->decl_table.put(record_decl->getCanonicalDecl(), trans_create_node_symbol(c, full_type_name));
+        c->decl_table.put(ZigClangRecordDecl_getCanonicalDecl(record_decl), trans_create_node_symbol(c, full_type_name));
     }
 
     uint32_t i = 0;
-    for (auto it = record_def->field_begin(),
-              it_end = record_def->field_end();
+    for (auto it = reinterpret_cast<const clang::RecordDecl *>(record_def)->field_begin(),
+              it_end = reinterpret_cast<const clang::RecordDecl *>(record_def)->field_end();
               it != it_end; ++it, i += 1)
     {
         const clang::FieldDecl *field_decl = *it;
 
         AstNode *field_node = trans_create_node(c, NodeTypeStructField);
-        field_node->data.struct_field.name = buf_create_from_str(decl_name(field_decl));
-        field_node->data.struct_field.type = trans_qual_type(c, field_decl->getType(), field_decl->getLocation());
+        field_node->data.struct_field.name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)field_decl));
+        field_node->data.struct_field.type = trans_qual_type(c, bitcast(field_decl->getType()),
+                bitcast(field_decl->getLocation()));
 
         if (field_node->data.struct_field.type == nullptr) {
-            emit_warning(c, field_decl->getLocation(),
+            emit_warning(c, bitcast(field_decl->getLocation()),
                     "%s %s demoted to opaque type - unresolved type",
                     container_kind_name,
                     is_anonymous ? "(anon)" : buf_ptr(bare_name));
@@ -4232,17 +4406,19 @@ static AstNode *resolve_record_decl(Context *c, const clang::RecordDecl *record_
     }
 }
 
-static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::QualType qt, const clang::SourceLocation &source_loc) {
-    switch (ap_value->getKind()) {
-        case clang::APValue::Int:
-            return trans_create_node_apint(c, ap_value->getInt());
-        case clang::APValue::Uninitialized:
+static AstNode *trans_ap_value(Context *c, const ZigClangAPValue *ap_value, ZigClangQualType qt,
+        ZigClangSourceLocation source_loc)
+{
+    switch (ZigClangAPValue_getKind(ap_value)) {
+        case ZigClangAPValueInt:
+            return trans_create_node_apint(c, ZigClangAPValue_getInt(ap_value));
+        case ZigClangAPValueUninitialized:
             return trans_create_node(c, NodeTypeUndefinedLiteral);
-        case clang::APValue::Array: {
+        case ZigClangAPValueArray: {
             emit_warning(c, source_loc, "TODO add a test case for this code");
 
-            unsigned init_count = ap_value->getArrayInitializedElts();
-            unsigned all_count = ap_value->getArraySize();
+            unsigned init_count = ZigClangAPValue_getArrayInitializedElts(ap_value);
+            unsigned all_count = ZigClangAPValue_getArraySize(ap_value);
             unsigned leftover_count = all_count - init_count;
             AstNode *init_node = trans_create_node(c, NodeTypeContainerInitExpr);
             AstNode *arr_type_node = trans_qual_type(c, qt, source_loc);
@@ -4252,11 +4428,12 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::Qual
             init_node->data.container_init_expr.type = arr_type_node;
             init_node->data.container_init_expr.kind = ContainerInitKindArray;
 
-            clang::QualType child_qt = qt.getTypePtr()->getAsArrayTypeUnsafe()->getElementType();
+            const clang::Type *qt_type = reinterpret_cast<const clang::Type *>(ZigClangQualType_getTypePtr(qt));
+            ZigClangQualType child_qt = bitcast(qt_type->getAsArrayTypeUnsafe()->getElementType());
 
             for (size_t i = 0; i < init_count; i += 1) {
-                clang::APValue &elem_ap_val = ap_value->getArrayInitializedElt(i);
-                AstNode *elem_node = trans_ap_value(c, &elem_ap_val, child_qt, source_loc);
+                const ZigClangAPValue *elem_ap_val = ZigClangAPValue_getArrayInitializedElt(ap_value, i);
+                AstNode *elem_node = trans_ap_value(c, elem_ap_val, child_qt, source_loc);
                 if (elem_node == nullptr)
                     return nullptr;
                 init_node->data.container_init_expr.entries.append(elem_node);
@@ -4265,8 +4442,8 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::Qual
                 return init_node;
             }
 
-            clang::APValue &filler_ap_val = ap_value->getArrayFiller();
-            AstNode *filler_node = trans_ap_value(c, &filler_ap_val, child_qt, source_loc);
+            const ZigClangAPValue *filler_ap_val = ZigClangAPValue_getArrayFiller(ap_value);
+            AstNode *filler_node = trans_ap_value(c, filler_ap_val, child_qt, source_loc);
             if (filler_node == nullptr)
                 return nullptr;
 
@@ -4293,37 +4470,37 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::Qual
 
             return trans_create_node_bin_op(c, init_node, BinOpTypeArrayCat, rhs_node);
         }
-        case clang::APValue::LValue: {
-            const clang::APValue::LValueBase lval_base = ap_value->getLValueBase();
-            if (const clang::Expr *expr = lval_base.dyn_cast<const clang::Expr *>()) {
+        case ZigClangAPValueLValue: {
+            const ZigClangAPValueLValueBase lval_base = ZigClangAPValue_getLValueBase(ap_value);
+            if (const ZigClangExpr *expr = ZigClangAPValueLValueBase_dyn_cast_Expr(lval_base)) {
                 return trans_expr(c, ResultUsedYes, &c->global_scope->base, expr, TransRValue);
             }
             //const clang::ValueDecl *value_decl = lval_base.get<const clang::ValueDecl *>();
             emit_warning(c, source_loc, "TODO handle initializer LValue clang::ValueDecl");
             return nullptr;
         }
-        case clang::APValue::Float:
+        case ZigClangAPValueFloat:
             emit_warning(c, source_loc, "unsupported initializer value kind: Float");
             return nullptr;
-        case clang::APValue::ComplexInt:
+        case ZigClangAPValueComplexInt:
             emit_warning(c, source_loc, "unsupported initializer value kind: ComplexInt");
             return nullptr;
-        case clang::APValue::ComplexFloat:
+        case ZigClangAPValueComplexFloat:
             emit_warning(c, source_loc, "unsupported initializer value kind: ComplexFloat");
             return nullptr;
-        case clang::APValue::Vector:
+        case ZigClangAPValueVector:
             emit_warning(c, source_loc, "unsupported initializer value kind: Vector");
             return nullptr;
-        case clang::APValue::Struct:
+        case ZigClangAPValueStruct:
             emit_warning(c, source_loc, "unsupported initializer value kind: Struct");
             return nullptr;
-        case clang::APValue::Union:
+        case ZigClangAPValueUnion:
             emit_warning(c, source_loc, "unsupported initializer value kind: Union");
             return nullptr;
-        case clang::APValue::MemberPointer:
+        case ZigClangAPValueMemberPointer:
             emit_warning(c, source_loc, "unsupported initializer value kind: MemberPointer");
             return nullptr;
-        case clang::APValue::AddrLabelDiff:
+        case ZigClangAPValueAddrLabelDiff:
             emit_warning(c, source_loc, "unsupported initializer value kind: AddrLabelDiff");
             return nullptr;
     }
@@ -4331,42 +4508,42 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::Qual
 }
 
 static void visit_var_decl(Context *c, const clang::VarDecl *var_decl) {
-    Buf *name = buf_create_from_str(decl_name(var_decl));
+    Buf *name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)var_decl));
 
     switch (var_decl->getTLSKind()) {
         case clang::VarDecl::TLS_None:
             break;
         case clang::VarDecl::TLS_Static:
-            emit_warning(c, var_decl->getLocation(),
+            emit_warning(c, bitcast(var_decl->getLocation()),
                     "ignoring variable '%s' - static thread local storage", buf_ptr(name));
             return;
         case clang::VarDecl::TLS_Dynamic:
-            emit_warning(c, var_decl->getLocation(),
+            emit_warning(c, bitcast(var_decl->getLocation()),
                     "ignoring variable '%s' - dynamic thread local storage", buf_ptr(name));
             return;
     }
 
-    clang::QualType qt = var_decl->getType();
-    AstNode *var_type = trans_qual_type(c, qt, var_decl->getLocation());
+    ZigClangQualType qt = bitcast(var_decl->getType());
+    AstNode *var_type = trans_qual_type(c, qt, bitcast(var_decl->getLocation()));
     if (var_type == nullptr) {
-        emit_warning(c, var_decl->getLocation(), "ignoring variable '%s' - unresolved type", buf_ptr(name));
+        emit_warning(c, bitcast(var_decl->getLocation()), "ignoring variable '%s' - unresolved type", buf_ptr(name));
         return;
     }
 
     bool is_extern = var_decl->hasExternalStorage();
     bool is_static = var_decl->isFileVarDecl();
-    bool is_const = qt.isConstQualified();
+    bool is_const = ZigClangQualType_isConstQualified(qt);
 
     if (is_static && !is_extern) {
         AstNode *init_node;
         if (var_decl->hasInit()) {
-            clang::APValue *ap_value = var_decl->evaluateValue();
+            const ZigClangAPValue *ap_value = bitcast(var_decl->evaluateValue());
             if (ap_value == nullptr) {
-                emit_warning(c, var_decl->getLocation(),
+                emit_warning(c, bitcast(var_decl->getLocation()),
                         "ignoring variable '%s' - unable to evaluate initializer", buf_ptr(name));
                 return;
             }
-            init_node = trans_ap_value(c, ap_value, qt, var_decl->getLocation());
+            init_node = trans_ap_value(c, ap_value, qt, bitcast(var_decl->getLocation()));
             if (init_node == nullptr)
                 return;
         } else {
@@ -4385,33 +4562,32 @@ static void visit_var_decl(Context *c, const clang::VarDecl *var_decl) {
         return;
     }
 
-    emit_warning(c, var_decl->getLocation(),
+    emit_warning(c, bitcast(var_decl->getLocation()),
         "ignoring variable '%s' - non-extern, non-static variable", buf_ptr(name));
     return;
 }
 
-static bool decl_visitor(void *context, const ZigClangDecl *zdecl) {
-    const clang::Decl *decl = reinterpret_cast<const clang::Decl *>(zdecl);
+static bool decl_visitor(void *context, const ZigClangDecl *decl) {
     Context *c = (Context*)context;
 
-    switch (decl->getKind()) {
-        case clang::Decl::Function:
-            visit_fn_decl(c, static_cast<const clang::FunctionDecl*>(decl));
+    switch (ZigClangDecl_getKind(decl)) {
+        case ZigClangDeclFunction:
+            visit_fn_decl(c, reinterpret_cast<const ZigClangFunctionDecl*>(decl));
             break;
-        case clang::Decl::Typedef:
-            resolve_typedef_decl(c, static_cast<const clang::TypedefNameDecl *>(decl));
+        case ZigClangDeclTypedef:
+            resolve_typedef_decl(c, reinterpret_cast<const ZigClangTypedefNameDecl *>(decl));
             break;
-        case clang::Decl::Enum:
-            resolve_enum_decl(c, static_cast<const clang::EnumDecl *>(decl));
+        case ZigClangDeclEnum:
+            resolve_enum_decl(c, reinterpret_cast<const ZigClangEnumDecl *>(decl));
             break;
-        case clang::Decl::Record:
-            resolve_record_decl(c, static_cast<const clang::RecordDecl *>(decl));
+        case ZigClangDeclRecord:
+            resolve_record_decl(c, reinterpret_cast<const ZigClangRecordDecl *>(decl));
             break;
-        case clang::Decl::Var:
-            visit_var_decl(c, static_cast<const clang::VarDecl *>(decl));
+        case ZigClangDeclVar:
+            visit_var_decl(c, reinterpret_cast<const clang::VarDecl *>(decl));
             break;
         default:
-            emit_warning(c, decl->getLocation(), "ignoring %s decl", decl->getDeclKindName());
+            emit_warning(c, ZigClangDecl_getLocation(decl), "ignoring %s decl", ZigClangDecl_getDeclKindName(decl));
     }
 
     return true;
@@ -4720,6 +4896,8 @@ static AstNode *parse_ctok_primary_expr(Context *c, CTokenize *ctok, size_t *tok
         case CTokIdAsterisk:
         case CTokIdBang:
         case CTokIdTilde:
+        case CTokIdShl:
+        case CTokIdLt:
             // not able to make sense of this
             return nullptr;
     }
@@ -4751,6 +4929,13 @@ static AstNode *parse_ctok_suffix_op_expr(Context *c, CTokenize *ctok, size_t *t
             *tok_i += 1;
 
             node = trans_create_node_ptr_type(c, false, false, node, PtrLenC);
+        } else if (first_tok->id == CTokIdShl) {
+            *tok_i += 1;
+
+            AstNode *rhs_node = parse_ctok_expr(c, ctok, tok_i);
+            if (rhs_node == nullptr)
+                return nullptr;
+            node = trans_create_node_bin_op(c, node, BinOpTypeBitShiftLeft, rhs_node);
         } else {
             return node;
         }
@@ -4846,10 +5031,10 @@ static void process_preprocessor_entities(Context *c, ZigClangASTUnit *zunit) {
                     clang::MacroDefinitionRecord *macro = static_cast<clang::MacroDefinitionRecord *>(entity);
                     const char *raw_name = macro->getName()->getNameStart();
                     clang::SourceRange range = macro->getSourceRange();
-                    clang::SourceLocation begin_loc = range.getBegin();
-                    clang::SourceLocation end_loc = range.getEnd();
+                    ZigClangSourceLocation begin_loc = bitcast(range.getBegin());
+                    ZigClangSourceLocation end_loc = bitcast(range.getEnd());
 
-                    if (begin_loc == end_loc) {
+                    if (ZigClangSourceLocation_eq(begin_loc, end_loc)) {
                         // this means it is a macro without a value
                         // we don't care about such things
                         continue;
@@ -4859,21 +5044,22 @@ static void process_preprocessor_entities(Context *c, ZigClangASTUnit *zunit) {
                         continue;
                     }
 
-                    const char *begin_c = ZigClangSourceManager_getCharacterData(c->source_manager, bitcast(begin_loc));
+                    const char *begin_c = ZigClangSourceManager_getCharacterData(c->source_manager, begin_loc);
                     process_macro(c, &ctok, name, begin_c);
                 }
         }
     }
 }
 
-Error parse_h_file(AstNode **out_root_node, ZigList<ErrorMsg *> *errors, const char *target_file,
-        CodeGen *codegen, Buf *tmp_dep_file)
+Error parse_h_file(CodeGen *codegen, AstNode **out_root_node,
+        Stage2ErrorMsg **errors_ptr, size_t *errors_len,
+        const char **args_begin, const char **args_end,
+        Stage2TranslateMode mode, const char *resources_path)
 {
     Context context = {0};
     Context *c = &context;
     c->warnings_on = codegen->verbose_cimport;
-    c->errors = errors;
-    if (buf_ends_with_str(buf_create_from_str(target_file), ".h")) {
+    if (mode == Stage2TranslateModeImport) {
         c->visib_mod = VisibModPub;
         c->want_export = false;
     } else {
@@ -4887,161 +5073,10 @@ Error parse_h_file(AstNode **out_root_node, ZigList<ErrorMsg *> *errors, const c
     c->codegen = codegen;
     c->global_scope = trans_scope_root_create(c);
 
-    ZigList<const char *> clang_argv = {0};
-
-    clang_argv.append("-x");
-    clang_argv.append("c");
-
-    if (tmp_dep_file != nullptr) {
-        clang_argv.append("-MD");
-        clang_argv.append("-MV");
-        clang_argv.append("-MF");
-        clang_argv.append(buf_ptr(tmp_dep_file));
-    }
-
-    if (c->codegen->zig_target->is_native) {
-        char *ZIG_PARSEC_CFLAGS = getenv("ZIG_NATIVE_PARSEC_CFLAGS");
-        if (ZIG_PARSEC_CFLAGS) {
-            Buf tmp_buf = BUF_INIT;
-            char *start = ZIG_PARSEC_CFLAGS;
-            char *space = strstr(start, " ");
-            while (space) {
-                if (space - start > 0) {
-                    buf_init_from_mem(&tmp_buf, start, space - start);
-                    clang_argv.append(buf_ptr(buf_create_from_buf(&tmp_buf)));
-                }
-                start = space + 1;
-                space = strstr(start, " ");
-            }
-            buf_init_from_str(&tmp_buf, start);
-            clang_argv.append(buf_ptr(buf_create_from_buf(&tmp_buf)));
-        }
-    }
-
-    clang_argv.append("-nobuiltininc");
-    clang_argv.append("-nostdinc");
-    clang_argv.append("-nostdinc++");
-    if (codegen->libc_link_lib == nullptr) {
-        clang_argv.append("-nolibc");
-    }
-
-    clang_argv.append("-isystem");
-    clang_argv.append(buf_ptr(codegen->zig_c_headers_dir));
-
-    for (size_t i = 0; i < codegen->libc_include_dir_len; i += 1) {
-        Buf *include_dir = codegen->libc_include_dir_list[i];
-        clang_argv.append("-isystem");
-        clang_argv.append(buf_ptr(include_dir));
-    }
-
-    // windows c runtime requires -D_DEBUG if using debug libraries
-    if (codegen->build_mode == BuildModeDebug) {
-        clang_argv.append("-D_DEBUG");
-    }
-
-    for (size_t i = 0; i < codegen->clang_argv_len; i += 1) {
-        clang_argv.append(codegen->clang_argv[i]);
-    }
-
-    // we don't need spell checking and it slows things down
-    clang_argv.append("-fno-spell-checking");
-
-    // this gives us access to preprocessing entities, presumably at
-    // the cost of performance
-    clang_argv.append("-Xclang");
-    clang_argv.append("-detailed-preprocessing-record");
-
-    if (c->codegen->zig_target->is_native) {
-        clang_argv.append("-march=native");
-    } else {
-        clang_argv.append("-target");
-        clang_argv.append(buf_ptr(&c->codegen->triple_str));
-    }
-
-    clang_argv.append(target_file);
-
-    if (codegen->verbose_cc) {
-        fprintf(stderr, "clang");
-        for (size_t i = 0; i < clang_argv.length; i += 1) {
-            fprintf(stderr, " %s", clang_argv.at(i));
-        }
-        fprintf(stderr, "\n");
-    }
-
-    // to make the [start...end] argument work
-    clang_argv.append(nullptr);
-
-    clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions));
-
-    std::shared_ptr<clang::PCHContainerOperations> pch_container_ops = std::make_shared<clang::PCHContainerOperations>();
-
-    bool only_local_decls = true;
-    bool capture_diagnostics = true;
-    bool user_files_are_volatile = true;
-    bool allow_pch_with_compiler_errors = false;
-    bool single_file_parse = false;
-    bool for_serialization = false;
-    const char *resources_path = buf_ptr(codegen->zig_c_headers_dir);
-    std::unique_ptr<clang::ASTUnit> err_unit;
-    ZigClangASTUnit *ast_unit = reinterpret_cast<ZigClangASTUnit *>(clang::ASTUnit::LoadFromCommandLine(
-            &clang_argv.at(0), &clang_argv.last(),
-            pch_container_ops, diags, resources_path,
-            only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete,
-            false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None,
-            single_file_parse, user_files_are_volatile, for_serialization, clang::None, &err_unit,
-            nullptr));
-
-    // Early failures in LoadFromCommandLine may return with ErrUnit unset.
-    if (!ast_unit && !err_unit) {
-        return ErrorFileSystem;
-    }
-
-    if (diags->getClient()->getNumErrors() > 0) {
-        if (ast_unit) {
-            err_unit = std::unique_ptr<clang::ASTUnit>(reinterpret_cast<clang::ASTUnit *>(ast_unit));
-        }
-
-        for (clang::ASTUnit::stored_diag_iterator it = err_unit->stored_diag_begin(),
-                it_end = err_unit->stored_diag_end();
-                it != it_end; ++it)
-        {
-            switch (it->getLevel()) {
-                case clang::DiagnosticsEngine::Ignored:
-                case clang::DiagnosticsEngine::Note:
-                case clang::DiagnosticsEngine::Remark:
-                case clang::DiagnosticsEngine::Warning:
-                    continue;
-                case clang::DiagnosticsEngine::Error:
-                case clang::DiagnosticsEngine::Fatal:
-                    break;
-            }
-            llvm::StringRef msg_str_ref = it->getMessage();
-            Buf *msg = string_ref_to_buf(msg_str_ref);
-            clang::FullSourceLoc fsl = it->getLocation();
-            if (fsl.hasManager()) {
-                clang::FileID file_id = fsl.getFileID();
-                clang::StringRef filename = fsl.getManager().getFilename(fsl);
-                unsigned line = fsl.getSpellingLineNumber() - 1;
-                unsigned column = fsl.getSpellingColumnNumber() - 1;
-                unsigned offset = fsl.getManager().getFileOffset(fsl);
-                const char *source = (const char *)fsl.getManager().getBufferData(file_id).bytes_begin();
-                Buf *path;
-                if (filename.empty()) {
-                    path = buf_alloc();
-                } else {
-                    path = string_ref_to_buf(filename);
-                }
-
-                ErrorMsg *err_msg = err_msg_create_with_offset(path, line, column, offset, source, msg);
-
-                c->errors->append(err_msg);
-            } else {
-                // NOTE the only known way this gets triggered right now is if you have a lot of errors
-                // clang emits "too many errors emitted, stopping now"
-                fprintf(stderr, "unexpected error from clang: %s\n", buf_ptr(msg));
-            }
-        }
-
+    ZigClangASTUnit *ast_unit = ZigClangLoadFromCommandLine(args_begin, args_end, errors_ptr, errors_len,
+            resources_path);
+    if (ast_unit == nullptr) {
+        if (*errors_len == 0) return ErrorNoMem;
         return ErrorCCompileErrors;
     }
 
@@ -5059,5 +5094,7 @@ Error parse_h_file(AstNode **out_root_node, ZigList<ErrorMsg *> *errors, const c
 
     *out_root_node = c->root;
 
+    ZigClangASTUnit_delete(ast_unit);
+
     return ErrorNone;
 }
diff --git a/src/translate_c.hpp b/src/translate_c.hpp
index 21461d2813..4eac26ddb5 100644
--- a/src/translate_c.hpp
+++ b/src/translate_c.hpp
@@ -11,7 +11,9 @@
 
 #include "all_types.hpp"
 
-Error parse_h_file(AstNode **out_root_node, ZigList<ErrorMsg *> *errors, const char *target_file,
-        CodeGen *codegen, Buf *tmp_dep_file);
+Error parse_h_file(CodeGen *codegen, AstNode **out_root_node,
+        Stage2ErrorMsg **errors_ptr, size_t *errors_len,
+        const char **args_begin, const char **args_end,
+        Stage2TranslateMode mode, const char *resources_path);
 
 #endif
diff --git a/src/userland.cpp b/src/userland.cpp
new file mode 100644
index 0000000000..20740711e5
--- /dev/null
+++ b/src/userland.cpp
@@ -0,0 +1,44 @@
+// This file is a shim for zig1. The real implementations of these are in
+// src-self-hosted/stage1.zig
+
+#include "userland.h"
+#include "ast_render.hpp"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+Error stage2_translate_c(struct Stage2Ast **out_ast,
+        struct Stage2ErrorMsg **out_errors_ptr, size_t *out_errors_len,
+        const char **args_begin, const char **args_end, enum Stage2TranslateMode mode,
+        const char *resources_path)
+{
+    const char *msg = "stage0 called stage2_translate_c";
+    stage2_panic(msg, strlen(msg));
+}
+
+void stage2_free_clang_errors(struct Stage2ErrorMsg *ptr, size_t len) {
+    const char *msg = "stage0 called stage2_free_clang_errors";
+    stage2_panic(msg, strlen(msg));
+}
+
+void stage2_zen(const char **ptr, size_t *len) {
+    const char *msg = "stage0 called stage2_zen";
+    stage2_panic(msg, strlen(msg));
+}
+
+void stage2_panic(const char *ptr, size_t len) {
+    fwrite(ptr, 1, len, stderr);
+    fprintf(stderr, "\n");
+    fflush(stderr);
+    abort();
+}
+
+void stage2_render_ast(struct Stage2Ast *ast, FILE *output_file) {
+    const char *msg = "stage0 called stage2_render_ast";
+    stage2_panic(msg, strlen(msg));
+}
+
+int stage2_fmt(int argc, char **argv) {
+    const char *msg = "stage0 called stage2_fmt";
+    stage2_panic(msg, strlen(msg));
+}
diff --git a/src/userland.h b/src/userland.h
new file mode 100644
index 0000000000..e48b80d0c2
--- /dev/null
+++ b/src/userland.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2019 Andrew Kelley
+ *
+ * This file is part of zig, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#ifndef ZIG_USERLAND_H
+#define ZIG_USERLAND_H
+
+#include <stddef.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+#define ZIG_EXTERN_C extern "C"
+#else
+#define ZIG_EXTERN_C
+#endif
+
+#if defined(_MSC_VER)
+#define ZIG_ATTRIBUTE_NORETURN __declspec(noreturn)
+#else
+#define ZIG_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#endif
+
+// ABI warning: the types and declarations in this file must match both those in
+// userland.cpp and src-self-hosted/stage1.zig.
+
+// ABI warning
+enum Error {
+    ErrorNone,
+    ErrorNoMem,
+    ErrorInvalidFormat,
+    ErrorSemanticAnalyzeFail,
+    ErrorAccess,
+    ErrorInterrupted,
+    ErrorSystemResources,
+    ErrorFileNotFound,
+    ErrorFileSystem,
+    ErrorFileTooBig,
+    ErrorDivByZero,
+    ErrorOverflow,
+    ErrorPathAlreadyExists,
+    ErrorUnexpected,
+    ErrorExactDivRemainder,
+    ErrorNegativeDenominator,
+    ErrorShiftedOutOneBits,
+    ErrorCCompileErrors,
+    ErrorEndOfFile,
+    ErrorIsDir,
+    ErrorNotDir,
+    ErrorUnsupportedOperatingSystem,
+    ErrorSharingViolation,
+    ErrorPipeBusy,
+    ErrorPrimitiveTypeNotFound,
+    ErrorCacheUnavailable,
+    ErrorPathTooLong,
+    ErrorCCompilerCannotFindFile,
+    ErrorReadingDepFile,
+    ErrorInvalidDepFile,
+    ErrorMissingArchitecture,
+    ErrorMissingOperatingSystem,
+    ErrorUnknownArchitecture,
+    ErrorUnknownOperatingSystem,
+    ErrorUnknownABI,
+    ErrorInvalidFilename,
+    ErrorDiskQuota,
+    ErrorDiskSpace,
+    ErrorUnexpectedWriteFailure,
+    ErrorUnexpectedSeekFailure,
+    ErrorUnexpectedFileTruncationFailure,
+    ErrorUnimplemented,
+    ErrorOperationAborted,
+    ErrorBrokenPipe,
+    ErrorNoSpaceLeft,
+};
+
+// ABI warning
+enum Stage2TranslateMode {
+    Stage2TranslateModeImport,
+    Stage2TranslateModeTranslate,
+};
+
+// ABI warning
+struct Stage2ErrorMsg {
+    const char *filename_ptr; // can be null
+    size_t filename_len;
+    const char *msg_ptr;
+    size_t msg_len;
+    const char *source; // valid until the ASTUnit is freed. can be null
+    unsigned line; // 0 based
+    unsigned column; // 0 based
+    unsigned offset; // byte offset into source
+};
+
+// ABI warning
+struct Stage2Ast;
+
+// ABI warning
+ZIG_EXTERN_C enum Error stage2_translate_c(struct Stage2Ast **out_ast,
+        struct Stage2ErrorMsg **out_errors_ptr, size_t *out_errors_len,
+        const char **args_begin, const char **args_end, enum Stage2TranslateMode mode,
+        const char *resources_path);
+
+// ABI warning
+ZIG_EXTERN_C void stage2_free_clang_errors(struct Stage2ErrorMsg *ptr, size_t len);
+
+// ABI warning
+ZIG_EXTERN_C void stage2_render_ast(struct Stage2Ast *ast, FILE *output_file);
+
+// ABI warning
+ZIG_EXTERN_C void stage2_zen(const char **ptr, size_t *len);
+
+// ABI warning
+ZIG_EXTERN_C ZIG_ATTRIBUTE_NORETURN void stage2_panic(const char *ptr, size_t len);
+
+// ABI warning
+ZIG_EXTERN_C int stage2_fmt(int argc, char **argv);
+
+#endif
diff --git a/src/util.cpp b/src/util.cpp
index 192d74e766..9a6a382993 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -10,17 +10,25 @@
 #include <stdarg.h>
 
 #include "util.hpp"
+#include "userland.h"
 
 void zig_panic(const char *format, ...) {
     va_list ap;
     va_start(ap, format);
     vfprintf(stderr, format, ap);
-    fprintf(stderr, "\n");
     fflush(stderr);
     va_end(ap);
+    stage2_panic(nullptr, 0);
     abort();
 }
 
+void assert(bool ok) {
+    if (!ok) {
+        const char *msg = "Assertion failed. This is a bug in the Zig compiler.";
+        stage2_panic(msg, strlen(msg));
+    }
+}
+
 uint32_t int_hash(int i) {
     return (uint32_t)(i % UINT32_MAX);
 }
diff --git a/src/util.hpp b/src/util.hpp
index 64c85033e3..f1942dd480 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -48,6 +48,10 @@ void zig_panic(const char *format, ...);
 
 #define zig_unreachable() zig_panic("unreachable: %s:%s:%d", __FILE__, __func__, __LINE__)
 
+// Assertions in stage1 are always on, and they call zig @panic.
+#undef assert
+void assert(bool ok);
+
 #if defined(_MSC_VER)
 static inline int clzll(unsigned long long mask) {
     unsigned long lz;
diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp
index 230c3c3116..b558fa318c 100644
--- a/src/zig_clang.cpp
+++ b/src/zig_clang.cpp
@@ -28,41 +28,41 @@
 #endif
 
 // Detect additions to the enum
-void zig2clang_BO(ZigClangBO op) {
+void ZigClang_detect_enum_BO(clang::BinaryOperatorKind op) {
     switch (op) {
-        case ZigClangBO_PtrMemD:
-        case ZigClangBO_PtrMemI:
-        case ZigClangBO_Cmp:
-        case ZigClangBO_Mul:
-        case ZigClangBO_Div:
-        case ZigClangBO_Rem:
-        case ZigClangBO_Add:
-        case ZigClangBO_Sub:
-        case ZigClangBO_Shl:
-        case ZigClangBO_Shr:
-        case ZigClangBO_LT:
-        case ZigClangBO_GT:
-        case ZigClangBO_LE:
-        case ZigClangBO_GE:
-        case ZigClangBO_EQ:
-        case ZigClangBO_NE:
-        case ZigClangBO_And:
-        case ZigClangBO_Xor:
-        case ZigClangBO_Or:
-        case ZigClangBO_LAnd:
-        case ZigClangBO_LOr:
-        case ZigClangBO_Assign:
-        case ZigClangBO_Comma:
-        case ZigClangBO_MulAssign:
-        case ZigClangBO_DivAssign:
-        case ZigClangBO_RemAssign:
-        case ZigClangBO_AddAssign:
-        case ZigClangBO_SubAssign:
-        case ZigClangBO_ShlAssign:
-        case ZigClangBO_ShrAssign:
-        case ZigClangBO_AndAssign:
-        case ZigClangBO_XorAssign:
-        case ZigClangBO_OrAssign:
+        case clang::BO_PtrMemD:
+        case clang::BO_PtrMemI:
+        case clang::BO_Cmp:
+        case clang::BO_Mul:
+        case clang::BO_Div:
+        case clang::BO_Rem:
+        case clang::BO_Add:
+        case clang::BO_Sub:
+        case clang::BO_Shl:
+        case clang::BO_Shr:
+        case clang::BO_LT:
+        case clang::BO_GT:
+        case clang::BO_LE:
+        case clang::BO_GE:
+        case clang::BO_EQ:
+        case clang::BO_NE:
+        case clang::BO_And:
+        case clang::BO_Xor:
+        case clang::BO_Or:
+        case clang::BO_LAnd:
+        case clang::BO_LOr:
+        case clang::BO_Assign:
+        case clang::BO_Comma:
+        case clang::BO_MulAssign:
+        case clang::BO_DivAssign:
+        case clang::BO_RemAssign:
+        case clang::BO_AddAssign:
+        case clang::BO_SubAssign:
+        case clang::BO_ShlAssign:
+        case clang::BO_ShrAssign:
+        case clang::BO_AndAssign:
+        case clang::BO_XorAssign:
+        case clang::BO_OrAssign:
             break;
     }
 }
@@ -101,23 +101,23 @@ static_assert((clang::BinaryOperatorKind)ZigClangBO_SubAssign == clang::BO_SubAs
 static_assert((clang::BinaryOperatorKind)ZigClangBO_Xor == clang::BO_Xor, "");
 static_assert((clang::BinaryOperatorKind)ZigClangBO_XorAssign == clang::BO_XorAssign, "");
 
-// This function detects additions to the enum
-void zig2clang_UO(ZigClangUO op) {
+// Detect additions to the enum
+void ZigClang_detect_enum_UO(clang::UnaryOperatorKind op) {
     switch (op) {
-        case ZigClangUO_AddrOf:
-        case ZigClangUO_Coawait:
-        case ZigClangUO_Deref:
-        case ZigClangUO_Extension:
-        case ZigClangUO_Imag:
-        case ZigClangUO_LNot:
-        case ZigClangUO_Minus:
-        case ZigClangUO_Not:
-        case ZigClangUO_Plus:
-        case ZigClangUO_PostDec:
-        case ZigClangUO_PostInc:
-        case ZigClangUO_PreDec:
-        case ZigClangUO_PreInc:
-        case ZigClangUO_Real:
+        case clang::UO_AddrOf:
+        case clang::UO_Coawait:
+        case clang::UO_Deref:
+        case clang::UO_Extension:
+        case clang::UO_Imag:
+        case clang::UO_LNot:
+        case clang::UO_Minus:
+        case clang::UO_Not:
+        case clang::UO_Plus:
+        case clang::UO_PostDec:
+        case clang::UO_PostInc:
+        case clang::UO_PreDec:
+        case clang::UO_PreInc:
+        case clang::UO_Real:
             break;
     }
 }
@@ -137,6 +137,1125 @@ static_assert((clang::UnaryOperatorKind)ZigClangUO_PreDec == clang::UO_PreDec, "
 static_assert((clang::UnaryOperatorKind)ZigClangUO_PreInc == clang::UO_PreInc, "");
 static_assert((clang::UnaryOperatorKind)ZigClangUO_Real == clang::UO_Real, "");
 
+// Detect additions to the enum
+void ZigClang_detect_enum_CK(clang::CastKind x) {
+    switch (x) {
+        case clang::CK_ARCConsumeObject:
+        case clang::CK_ARCExtendBlockObject:
+        case clang::CK_ARCProduceObject:
+        case clang::CK_ARCReclaimReturnedObject:
+        case clang::CK_AddressSpaceConversion:
+        case clang::CK_AnyPointerToBlockPointerCast:
+        case clang::CK_ArrayToPointerDecay:
+        case clang::CK_AtomicToNonAtomic:
+        case clang::CK_BaseToDerived:
+        case clang::CK_BaseToDerivedMemberPointer:
+        case clang::CK_BitCast:
+        case clang::CK_BlockPointerToObjCPointerCast:
+        case clang::CK_BooleanToSignedIntegral:
+        case clang::CK_BuiltinFnToFnPtr:
+        case clang::CK_CPointerToObjCPointerCast:
+        case clang::CK_ConstructorConversion:
+        case clang::CK_CopyAndAutoreleaseBlockObject:
+        case clang::CK_Dependent:
+        case clang::CK_DerivedToBase:
+        case clang::CK_DerivedToBaseMemberPointer:
+        case clang::CK_Dynamic:
+        case clang::CK_FloatingCast:
+        case clang::CK_FloatingComplexCast:
+        case clang::CK_FloatingComplexToBoolean:
+        case clang::CK_FloatingComplexToIntegralComplex:
+        case clang::CK_FloatingComplexToReal:
+        case clang::CK_FloatingRealToComplex:
+        case clang::CK_FloatingToBoolean:
+        case clang::CK_FloatingToIntegral:
+        case clang::CK_FunctionToPointerDecay:
+        case clang::CK_IntToOCLSampler:
+        case clang::CK_IntegralCast:
+        case clang::CK_IntegralComplexCast:
+        case clang::CK_IntegralComplexToBoolean:
+        case clang::CK_IntegralComplexToFloatingComplex:
+        case clang::CK_IntegralComplexToReal:
+        case clang::CK_IntegralRealToComplex:
+        case clang::CK_IntegralToBoolean:
+        case clang::CK_IntegralToFloating:
+        case clang::CK_IntegralToPointer:
+        case clang::CK_LValueBitCast:
+        case clang::CK_LValueToRValue:
+        case clang::CK_MemberPointerToBoolean:
+        case clang::CK_NoOp:
+        case clang::CK_NonAtomicToAtomic:
+        case clang::CK_NullToMemberPointer:
+        case clang::CK_NullToPointer:
+        case clang::CK_ObjCObjectLValueCast:
+        case clang::CK_PointerToBoolean:
+        case clang::CK_PointerToIntegral:
+        case clang::CK_ReinterpretMemberPointer:
+        case clang::CK_ToUnion:
+        case clang::CK_ToVoid:
+        case clang::CK_UncheckedDerivedToBase:
+        case clang::CK_UserDefinedConversion:
+        case clang::CK_VectorSplat:
+        case clang::CK_ZeroToOCLOpaqueType:
+        case clang::CK_FixedPointCast:
+        case clang::CK_FixedPointToBoolean:
+            break;
+    }
+};
+
+static_assert((clang::CastKind)ZigClangCK_Dependent == clang::CK_Dependent, "");
+static_assert((clang::CastKind)ZigClangCK_BitCast == clang::CK_BitCast, "");
+static_assert((clang::CastKind)ZigClangCK_LValueBitCast == clang::CK_LValueBitCast, "");
+static_assert((clang::CastKind)ZigClangCK_LValueToRValue == clang::CK_LValueToRValue, "");
+static_assert((clang::CastKind)ZigClangCK_NoOp == clang::CK_NoOp, "");
+static_assert((clang::CastKind)ZigClangCK_BaseToDerived == clang::CK_BaseToDerived, "");
+static_assert((clang::CastKind)ZigClangCK_DerivedToBase == clang::CK_DerivedToBase, "");
+static_assert((clang::CastKind)ZigClangCK_UncheckedDerivedToBase == clang::CK_UncheckedDerivedToBase, "");
+static_assert((clang::CastKind)ZigClangCK_Dynamic == clang::CK_Dynamic, "");
+static_assert((clang::CastKind)ZigClangCK_ToUnion == clang::CK_ToUnion, "");
+static_assert((clang::CastKind)ZigClangCK_ArrayToPointerDecay == clang::CK_ArrayToPointerDecay, "");
+static_assert((clang::CastKind)ZigClangCK_FunctionToPointerDecay == clang::CK_FunctionToPointerDecay, "");
+static_assert((clang::CastKind)ZigClangCK_NullToPointer == clang::CK_NullToPointer, "");
+static_assert((clang::CastKind)ZigClangCK_NullToMemberPointer == clang::CK_NullToMemberPointer, "");
+static_assert((clang::CastKind)ZigClangCK_BaseToDerivedMemberPointer == clang::CK_BaseToDerivedMemberPointer, "");
+static_assert((clang::CastKind)ZigClangCK_DerivedToBaseMemberPointer == clang::CK_DerivedToBaseMemberPointer, "");
+static_assert((clang::CastKind)ZigClangCK_MemberPointerToBoolean == clang::CK_MemberPointerToBoolean, "");
+static_assert((clang::CastKind)ZigClangCK_ReinterpretMemberPointer == clang::CK_ReinterpretMemberPointer, "");
+static_assert((clang::CastKind)ZigClangCK_UserDefinedConversion == clang::CK_UserDefinedConversion, "");
+static_assert((clang::CastKind)ZigClangCK_ConstructorConversion == clang::CK_ConstructorConversion, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralToPointer == clang::CK_IntegralToPointer, "");
+static_assert((clang::CastKind)ZigClangCK_PointerToIntegral == clang::CK_PointerToIntegral, "");
+static_assert((clang::CastKind)ZigClangCK_PointerToBoolean == clang::CK_PointerToBoolean, "");
+static_assert((clang::CastKind)ZigClangCK_ToVoid == clang::CK_ToVoid, "");
+static_assert((clang::CastKind)ZigClangCK_VectorSplat == clang::CK_VectorSplat, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralCast == clang::CK_IntegralCast, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralToBoolean == clang::CK_IntegralToBoolean, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralToFloating == clang::CK_IntegralToFloating, "");
+static_assert((clang::CastKind)ZigClangCK_FixedPointCast == clang::CK_FixedPointCast, "");
+static_assert((clang::CastKind)ZigClangCK_FixedPointToBoolean == clang::CK_FixedPointToBoolean, "");
+static_assert((clang::CastKind)ZigClangCK_FloatingToIntegral == clang::CK_FloatingToIntegral, "");
+static_assert((clang::CastKind)ZigClangCK_FloatingToBoolean == clang::CK_FloatingToBoolean, "");
+static_assert((clang::CastKind)ZigClangCK_BooleanToSignedIntegral == clang::CK_BooleanToSignedIntegral, "");
+static_assert((clang::CastKind)ZigClangCK_FloatingCast == clang::CK_FloatingCast, "");
+static_assert((clang::CastKind)ZigClangCK_CPointerToObjCPointerCast == clang::CK_CPointerToObjCPointerCast, "");
+static_assert((clang::CastKind)ZigClangCK_BlockPointerToObjCPointerCast == clang::CK_BlockPointerToObjCPointerCast, "");
+static_assert((clang::CastKind)ZigClangCK_AnyPointerToBlockPointerCast == clang::CK_AnyPointerToBlockPointerCast, "");
+static_assert((clang::CastKind)ZigClangCK_ObjCObjectLValueCast == clang::CK_ObjCObjectLValueCast, "");
+static_assert((clang::CastKind)ZigClangCK_FloatingRealToComplex == clang::CK_FloatingRealToComplex, "");
+static_assert((clang::CastKind)ZigClangCK_FloatingComplexToReal == clang::CK_FloatingComplexToReal, "");
+static_assert((clang::CastKind)ZigClangCK_FloatingComplexToBoolean == clang::CK_FloatingComplexToBoolean, "");
+static_assert((clang::CastKind)ZigClangCK_FloatingComplexCast == clang::CK_FloatingComplexCast, "");
+static_assert((clang::CastKind)ZigClangCK_FloatingComplexToIntegralComplex == clang::CK_FloatingComplexToIntegralComplex, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralRealToComplex == clang::CK_IntegralRealToComplex, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralComplexToReal == clang::CK_IntegralComplexToReal, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralComplexToBoolean == clang::CK_IntegralComplexToBoolean, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralComplexCast == clang::CK_IntegralComplexCast, "");
+static_assert((clang::CastKind)ZigClangCK_IntegralComplexToFloatingComplex == clang::CK_IntegralComplexToFloatingComplex, "");
+static_assert((clang::CastKind)ZigClangCK_ARCProduceObject == clang::CK_ARCProduceObject, "");
+static_assert((clang::CastKind)ZigClangCK_ARCConsumeObject == clang::CK_ARCConsumeObject, "");
+static_assert((clang::CastKind)ZigClangCK_ARCReclaimReturnedObject == clang::CK_ARCReclaimReturnedObject, "");
+static_assert((clang::CastKind)ZigClangCK_ARCExtendBlockObject == clang::CK_ARCExtendBlockObject, "");
+static_assert((clang::CastKind)ZigClangCK_AtomicToNonAtomic == clang::CK_AtomicToNonAtomic, "");
+static_assert((clang::CastKind)ZigClangCK_NonAtomicToAtomic == clang::CK_NonAtomicToAtomic, "");
+static_assert((clang::CastKind)ZigClangCK_CopyAndAutoreleaseBlockObject == clang::CK_CopyAndAutoreleaseBlockObject, "");
+static_assert((clang::CastKind)ZigClangCK_BuiltinFnToFnPtr == clang::CK_BuiltinFnToFnPtr, "");
+static_assert((clang::CastKind)ZigClangCK_ZeroToOCLOpaqueType == clang::CK_ZeroToOCLOpaqueType, "");
+static_assert((clang::CastKind)ZigClangCK_AddressSpaceConversion == clang::CK_AddressSpaceConversion, "");
+static_assert((clang::CastKind)ZigClangCK_IntToOCLSampler == clang::CK_IntToOCLSampler, "");
+
+// Detect additions to the enum
+void ZigClang_detect_enum_TypeClass(clang::Type::TypeClass ty) {
+    switch (ty) {
+        case clang::Type::Builtin:
+        case clang::Type::Complex:
+        case clang::Type::Pointer:
+        case clang::Type::BlockPointer:
+        case clang::Type::LValueReference:
+        case clang::Type::RValueReference:
+        case clang::Type::MemberPointer:
+        case clang::Type::ConstantArray:
+        case clang::Type::IncompleteArray:
+        case clang::Type::VariableArray:
+        case clang::Type::DependentSizedArray:
+        case clang::Type::DependentSizedExtVector:
+        case clang::Type::DependentAddressSpace:
+        case clang::Type::Vector:
+        case clang::Type::DependentVector:
+        case clang::Type::ExtVector:
+        case clang::Type::FunctionProto:
+        case clang::Type::FunctionNoProto:
+        case clang::Type::UnresolvedUsing:
+        case clang::Type::Paren:
+        case clang::Type::Typedef:
+        case clang::Type::Adjusted:
+        case clang::Type::Decayed:
+        case clang::Type::TypeOfExpr:
+        case clang::Type::TypeOf:
+        case clang::Type::Decltype:
+        case clang::Type::UnaryTransform:
+        case clang::Type::Record:
+        case clang::Type::Enum:
+        case clang::Type::Elaborated:
+        case clang::Type::Attributed:
+        case clang::Type::TemplateTypeParm:
+        case clang::Type::SubstTemplateTypeParm:
+        case clang::Type::SubstTemplateTypeParmPack:
+        case clang::Type::TemplateSpecialization:
+        case clang::Type::Auto:
+        case clang::Type::DeducedTemplateSpecialization:
+        case clang::Type::InjectedClassName:
+        case clang::Type::DependentName:
+        case clang::Type::DependentTemplateSpecialization:
+        case clang::Type::PackExpansion:
+        case clang::Type::ObjCTypeParam:
+        case clang::Type::ObjCObject:
+        case clang::Type::ObjCInterface:
+        case clang::Type::ObjCObjectPointer:
+        case clang::Type::Pipe:
+        case clang::Type::Atomic:
+            break;
+    }
+}
+
+static_assert((clang::Type::TypeClass)ZigClangType_Builtin == clang::Type::Builtin, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Complex == clang::Type::Complex, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Pointer == clang::Type::Pointer, "");
+static_assert((clang::Type::TypeClass)ZigClangType_BlockPointer == clang::Type::BlockPointer, "");
+static_assert((clang::Type::TypeClass)ZigClangType_LValueReference == clang::Type::LValueReference, "");
+static_assert((clang::Type::TypeClass)ZigClangType_RValueReference == clang::Type::RValueReference, "");
+static_assert((clang::Type::TypeClass)ZigClangType_MemberPointer == clang::Type::MemberPointer, "");
+static_assert((clang::Type::TypeClass)ZigClangType_ConstantArray == clang::Type::ConstantArray, "");
+static_assert((clang::Type::TypeClass)ZigClangType_IncompleteArray == clang::Type::IncompleteArray, "");
+static_assert((clang::Type::TypeClass)ZigClangType_VariableArray == clang::Type::VariableArray, "");
+static_assert((clang::Type::TypeClass)ZigClangType_DependentSizedArray == clang::Type::DependentSizedArray, "");
+static_assert((clang::Type::TypeClass)ZigClangType_DependentSizedExtVector == clang::Type::DependentSizedExtVector, "");
+static_assert((clang::Type::TypeClass)ZigClangType_DependentAddressSpace == clang::Type::DependentAddressSpace, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Vector == clang::Type::Vector, "");
+static_assert((clang::Type::TypeClass)ZigClangType_DependentVector == clang::Type::DependentVector, "");
+static_assert((clang::Type::TypeClass)ZigClangType_ExtVector == clang::Type::ExtVector, "");
+static_assert((clang::Type::TypeClass)ZigClangType_FunctionProto == clang::Type::FunctionProto, "");
+static_assert((clang::Type::TypeClass)ZigClangType_FunctionNoProto == clang::Type::FunctionNoProto, "");
+static_assert((clang::Type::TypeClass)ZigClangType_UnresolvedUsing == clang::Type::UnresolvedUsing, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Paren == clang::Type::Paren, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Typedef == clang::Type::Typedef, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Adjusted == clang::Type::Adjusted, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Decayed == clang::Type::Decayed, "");
+static_assert((clang::Type::TypeClass)ZigClangType_TypeOfExpr == clang::Type::TypeOfExpr, "");
+static_assert((clang::Type::TypeClass)ZigClangType_TypeOf == clang::Type::TypeOf, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Decltype == clang::Type::Decltype, "");
+static_assert((clang::Type::TypeClass)ZigClangType_UnaryTransform == clang::Type::UnaryTransform, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Record == clang::Type::Record, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Enum == clang::Type::Enum, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Elaborated == clang::Type::Elaborated, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Attributed == clang::Type::Attributed, "");
+static_assert((clang::Type::TypeClass)ZigClangType_TemplateTypeParm == clang::Type::TemplateTypeParm, "");
+static_assert((clang::Type::TypeClass)ZigClangType_SubstTemplateTypeParm == clang::Type::SubstTemplateTypeParm, "");
+static_assert((clang::Type::TypeClass)ZigClangType_SubstTemplateTypeParmPack == clang::Type::SubstTemplateTypeParmPack, "");
+static_assert((clang::Type::TypeClass)ZigClangType_TemplateSpecialization == clang::Type::TemplateSpecialization, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Auto == clang::Type::Auto, "");
+static_assert((clang::Type::TypeClass)ZigClangType_DeducedTemplateSpecialization == clang::Type::DeducedTemplateSpecialization, "");
+static_assert((clang::Type::TypeClass)ZigClangType_InjectedClassName == clang::Type::InjectedClassName, "");
+static_assert((clang::Type::TypeClass)ZigClangType_DependentName == clang::Type::DependentName, "");
+static_assert((clang::Type::TypeClass)ZigClangType_DependentTemplateSpecialization == clang::Type::DependentTemplateSpecialization, "");
+static_assert((clang::Type::TypeClass)ZigClangType_PackExpansion == clang::Type::PackExpansion, "");
+static_assert((clang::Type::TypeClass)ZigClangType_ObjCTypeParam == clang::Type::ObjCTypeParam, "");
+static_assert((clang::Type::TypeClass)ZigClangType_ObjCObject == clang::Type::ObjCObject, "");
+static_assert((clang::Type::TypeClass)ZigClangType_ObjCInterface == clang::Type::ObjCInterface, "");
+static_assert((clang::Type::TypeClass)ZigClangType_ObjCObjectPointer == clang::Type::ObjCObjectPointer, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Pipe == clang::Type::Pipe, "");
+static_assert((clang::Type::TypeClass)ZigClangType_Atomic == clang::Type::Atomic, "");
+
+// Detect additions to the enum
+void ZigClang_detect_enum_StmtClass(clang::Stmt::StmtClass x) {
+    switch (x) {
+        case clang::Stmt::NoStmtClass:
+        case clang::Stmt::NullStmtClass:
+        case clang::Stmt::CompoundStmtClass:
+        case clang::Stmt::LabelStmtClass:
+        case clang::Stmt::AttributedStmtClass:
+        case clang::Stmt::IfStmtClass:
+        case clang::Stmt::SwitchStmtClass:
+        case clang::Stmt::WhileStmtClass:
+        case clang::Stmt::DoStmtClass:
+        case clang::Stmt::ForStmtClass:
+        case clang::Stmt::GotoStmtClass:
+        case clang::Stmt::IndirectGotoStmtClass:
+        case clang::Stmt::ContinueStmtClass:
+        case clang::Stmt::BreakStmtClass:
+        case clang::Stmt::ReturnStmtClass:
+        case clang::Stmt::DeclStmtClass:
+        case clang::Stmt::CaseStmtClass:
+        case clang::Stmt::DefaultStmtClass:
+        case clang::Stmt::CapturedStmtClass:
+        case clang::Stmt::GCCAsmStmtClass:
+        case clang::Stmt::MSAsmStmtClass:
+        case clang::Stmt::ObjCAtTryStmtClass:
+        case clang::Stmt::ObjCAtCatchStmtClass:
+        case clang::Stmt::ObjCAtFinallyStmtClass:
+        case clang::Stmt::ObjCAtThrowStmtClass:
+        case clang::Stmt::ObjCAtSynchronizedStmtClass:
+        case clang::Stmt::ObjCForCollectionStmtClass:
+        case clang::Stmt::ObjCAutoreleasePoolStmtClass:
+        case clang::Stmt::CXXCatchStmtClass:
+        case clang::Stmt::CXXTryStmtClass:
+        case clang::Stmt::CXXForRangeStmtClass:
+        case clang::Stmt::CoroutineBodyStmtClass:
+        case clang::Stmt::CoreturnStmtClass:
+        case clang::Stmt::PredefinedExprClass:
+        case clang::Stmt::DeclRefExprClass:
+        case clang::Stmt::IntegerLiteralClass:
+        case clang::Stmt::FixedPointLiteralClass:
+        case clang::Stmt::FloatingLiteralClass:
+        case clang::Stmt::ImaginaryLiteralClass:
+        case clang::Stmt::StringLiteralClass:
+        case clang::Stmt::CharacterLiteralClass:
+        case clang::Stmt::ParenExprClass:
+        case clang::Stmt::UnaryOperatorClass:
+        case clang::Stmt::OffsetOfExprClass:
+        case clang::Stmt::UnaryExprOrTypeTraitExprClass:
+        case clang::Stmt::ArraySubscriptExprClass:
+        case clang::Stmt::OMPArraySectionExprClass:
+        case clang::Stmt::CallExprClass:
+        case clang::Stmt::MemberExprClass:
+        case clang::Stmt::BinaryOperatorClass:
+        case clang::Stmt::CompoundAssignOperatorClass:
+        case clang::Stmt::ConditionalOperatorClass:
+        case clang::Stmt::BinaryConditionalOperatorClass:
+        case clang::Stmt::ImplicitCastExprClass:
+        case clang::Stmt::CStyleCastExprClass:
+        case clang::Stmt::CompoundLiteralExprClass:
+        case clang::Stmt::ExtVectorElementExprClass:
+        case clang::Stmt::InitListExprClass:
+        case clang::Stmt::DesignatedInitExprClass:
+        case clang::Stmt::DesignatedInitUpdateExprClass:
+        case clang::Stmt::ImplicitValueInitExprClass:
+        case clang::Stmt::NoInitExprClass:
+        case clang::Stmt::ArrayInitLoopExprClass:
+        case clang::Stmt::ArrayInitIndexExprClass:
+        case clang::Stmt::ParenListExprClass:
+        case clang::Stmt::VAArgExprClass:
+        case clang::Stmt::GenericSelectionExprClass:
+        case clang::Stmt::PseudoObjectExprClass:
+        case clang::Stmt::ConstantExprClass:
+        case clang::Stmt::AtomicExprClass:
+        case clang::Stmt::AddrLabelExprClass:
+        case clang::Stmt::StmtExprClass:
+        case clang::Stmt::ChooseExprClass:
+        case clang::Stmt::GNUNullExprClass:
+        case clang::Stmt::CXXOperatorCallExprClass:
+        case clang::Stmt::CXXMemberCallExprClass:
+        case clang::Stmt::CXXStaticCastExprClass:
+        case clang::Stmt::CXXDynamicCastExprClass:
+        case clang::Stmt::CXXReinterpretCastExprClass:
+        case clang::Stmt::CXXConstCastExprClass:
+        case clang::Stmt::CXXFunctionalCastExprClass:
+        case clang::Stmt::CXXTypeidExprClass:
+        case clang::Stmt::UserDefinedLiteralClass:
+        case clang::Stmt::CXXBoolLiteralExprClass:
+        case clang::Stmt::CXXNullPtrLiteralExprClass:
+        case clang::Stmt::CXXThisExprClass:
+        case clang::Stmt::CXXThrowExprClass:
+        case clang::Stmt::CXXDefaultArgExprClass:
+        case clang::Stmt::CXXDefaultInitExprClass:
+        case clang::Stmt::CXXScalarValueInitExprClass:
+        case clang::Stmt::CXXStdInitializerListExprClass:
+        case clang::Stmt::CXXNewExprClass:
+        case clang::Stmt::CXXDeleteExprClass:
+        case clang::Stmt::CXXPseudoDestructorExprClass:
+        case clang::Stmt::TypeTraitExprClass:
+        case clang::Stmt::ArrayTypeTraitExprClass:
+        case clang::Stmt::ExpressionTraitExprClass:
+        case clang::Stmt::DependentScopeDeclRefExprClass:
+        case clang::Stmt::CXXConstructExprClass:
+        case clang::Stmt::CXXInheritedCtorInitExprClass:
+        case clang::Stmt::CXXBindTemporaryExprClass:
+        case clang::Stmt::ExprWithCleanupsClass:
+        case clang::Stmt::CXXTemporaryObjectExprClass:
+        case clang::Stmt::CXXUnresolvedConstructExprClass:
+        case clang::Stmt::CXXDependentScopeMemberExprClass:
+        case clang::Stmt::UnresolvedLookupExprClass:
+        case clang::Stmt::UnresolvedMemberExprClass:
+        case clang::Stmt::CXXNoexceptExprClass:
+        case clang::Stmt::PackExpansionExprClass:
+        case clang::Stmt::SizeOfPackExprClass:
+        case clang::Stmt::SubstNonTypeTemplateParmExprClass:
+        case clang::Stmt::SubstNonTypeTemplateParmPackExprClass:
+        case clang::Stmt::FunctionParmPackExprClass:
+        case clang::Stmt::MaterializeTemporaryExprClass:
+        case clang::Stmt::LambdaExprClass:
+        case clang::Stmt::CXXFoldExprClass:
+        case clang::Stmt::CoawaitExprClass:
+        case clang::Stmt::DependentCoawaitExprClass:
+        case clang::Stmt::CoyieldExprClass:
+        case clang::Stmt::ObjCStringLiteralClass:
+        case clang::Stmt::ObjCBoxedExprClass:
+        case clang::Stmt::ObjCArrayLiteralClass:
+        case clang::Stmt::ObjCDictionaryLiteralClass:
+        case clang::Stmt::ObjCEncodeExprClass:
+        case clang::Stmt::ObjCMessageExprClass:
+        case clang::Stmt::ObjCSelectorExprClass:
+        case clang::Stmt::ObjCProtocolExprClass:
+        case clang::Stmt::ObjCIvarRefExprClass:
+        case clang::Stmt::ObjCPropertyRefExprClass:
+        case clang::Stmt::ObjCIsaExprClass:
+        case clang::Stmt::ObjCIndirectCopyRestoreExprClass:
+        case clang::Stmt::ObjCBoolLiteralExprClass:
+        case clang::Stmt::ObjCSubscriptRefExprClass:
+        case clang::Stmt::ObjCAvailabilityCheckExprClass:
+        case clang::Stmt::ObjCBridgedCastExprClass:
+        case clang::Stmt::CUDAKernelCallExprClass:
+        case clang::Stmt::ShuffleVectorExprClass:
+        case clang::Stmt::ConvertVectorExprClass:
+        case clang::Stmt::BlockExprClass:
+        case clang::Stmt::OpaqueValueExprClass:
+        case clang::Stmt::TypoExprClass:
+        case clang::Stmt::MSPropertyRefExprClass:
+        case clang::Stmt::MSPropertySubscriptExprClass:
+        case clang::Stmt::CXXUuidofExprClass:
+        case clang::Stmt::SEHTryStmtClass:
+        case clang::Stmt::SEHExceptStmtClass:
+        case clang::Stmt::SEHFinallyStmtClass:
+        case clang::Stmt::SEHLeaveStmtClass:
+        case clang::Stmt::MSDependentExistsStmtClass:
+        case clang::Stmt::AsTypeExprClass:
+        case clang::Stmt::OMPParallelDirectiveClass:
+        case clang::Stmt::OMPSimdDirectiveClass:
+        case clang::Stmt::OMPForDirectiveClass:
+        case clang::Stmt::OMPForSimdDirectiveClass:
+        case clang::Stmt::OMPSectionsDirectiveClass:
+        case clang::Stmt::OMPSectionDirectiveClass:
+        case clang::Stmt::OMPSingleDirectiveClass:
+        case clang::Stmt::OMPMasterDirectiveClass:
+        case clang::Stmt::OMPCriticalDirectiveClass:
+        case clang::Stmt::OMPParallelForDirectiveClass:
+        case clang::Stmt::OMPParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPParallelSectionsDirectiveClass:
+        case clang::Stmt::OMPTaskDirectiveClass:
+        case clang::Stmt::OMPTaskyieldDirectiveClass:
+        case clang::Stmt::OMPBarrierDirectiveClass:
+        case clang::Stmt::OMPTaskwaitDirectiveClass:
+        case clang::Stmt::OMPTaskgroupDirectiveClass:
+        case clang::Stmt::OMPFlushDirectiveClass:
+        case clang::Stmt::OMPOrderedDirectiveClass:
+        case clang::Stmt::OMPAtomicDirectiveClass:
+        case clang::Stmt::OMPTargetDirectiveClass:
+        case clang::Stmt::OMPTargetDataDirectiveClass:
+        case clang::Stmt::OMPTargetEnterDataDirectiveClass:
+        case clang::Stmt::OMPTargetExitDataDirectiveClass:
+        case clang::Stmt::OMPTargetParallelDirectiveClass:
+        case clang::Stmt::OMPTargetParallelForDirectiveClass:
+        case clang::Stmt::OMPTargetUpdateDirectiveClass:
+        case clang::Stmt::OMPTeamsDirectiveClass:
+        case clang::Stmt::OMPCancellationPointDirectiveClass:
+        case clang::Stmt::OMPCancelDirectiveClass:
+        case clang::Stmt::OMPTaskLoopDirectiveClass:
+        case clang::Stmt::OMPTaskLoopSimdDirectiveClass:
+        case clang::Stmt::OMPDistributeDirectiveClass:
+        case clang::Stmt::OMPDistributeParallelForDirectiveClass:
+        case clang::Stmt::OMPDistributeParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPDistributeSimdDirectiveClass:
+        case clang::Stmt::OMPTargetParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPTargetSimdDirectiveClass:
+        case clang::Stmt::OMPTeamsDistributeDirectiveClass:
+        case clang::Stmt::OMPTeamsDistributeSimdDirectiveClass:
+        case clang::Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPTeamsDistributeParallelForDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDistributeDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
+        case clang::Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
+            break;
+    }
+}
+
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_NoStmtClass == clang::Stmt::NoStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_NullStmtClass == clang::Stmt::NullStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CompoundStmtClass == clang::Stmt::CompoundStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_LabelStmtClass == clang::Stmt::LabelStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_AttributedStmtClass == clang::Stmt::AttributedStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_IfStmtClass == clang::Stmt::IfStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SwitchStmtClass == clang::Stmt::SwitchStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_WhileStmtClass == clang::Stmt::WhileStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_DoStmtClass == clang::Stmt::DoStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ForStmtClass == clang::Stmt::ForStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_GotoStmtClass == clang::Stmt::GotoStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_IndirectGotoStmtClass == clang::Stmt::IndirectGotoStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ContinueStmtClass == clang::Stmt::ContinueStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_BreakStmtClass == clang::Stmt::BreakStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ReturnStmtClass == clang::Stmt::ReturnStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_DeclStmtClass == clang::Stmt::DeclStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CaseStmtClass == clang::Stmt::CaseStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_DefaultStmtClass == clang::Stmt::DefaultStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CapturedStmtClass == clang::Stmt::CapturedStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_GCCAsmStmtClass == clang::Stmt::GCCAsmStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSAsmStmtClass == clang::Stmt::MSAsmStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtTryStmtClass == clang::Stmt::ObjCAtTryStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtCatchStmtClass == clang::Stmt::ObjCAtCatchStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtFinallyStmtClass == clang::Stmt::ObjCAtFinallyStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtThrowStmtClass == clang::Stmt::ObjCAtThrowStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtSynchronizedStmtClass == clang::Stmt::ObjCAtSynchronizedStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCForCollectionStmtClass == clang::Stmt::ObjCForCollectionStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAutoreleasePoolStmtClass == clang::Stmt::ObjCAutoreleasePoolStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXCatchStmtClass == clang::Stmt::CXXCatchStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXTryStmtClass == clang::Stmt::CXXTryStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXForRangeStmtClass == clang::Stmt::CXXForRangeStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CoroutineBodyStmtClass == clang::Stmt::CoroutineBodyStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CoreturnStmtClass == clang::Stmt::CoreturnStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_PredefinedExprClass == clang::Stmt::PredefinedExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_DeclRefExprClass == clang::Stmt::DeclRefExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_IntegerLiteralClass == clang::Stmt::IntegerLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_FixedPointLiteralClass == clang::Stmt::FixedPointLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_FloatingLiteralClass == clang::Stmt::FloatingLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ImaginaryLiteralClass == clang::Stmt::ImaginaryLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_StringLiteralClass == clang::Stmt::StringLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CharacterLiteralClass == clang::Stmt::CharacterLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ParenExprClass == clang::Stmt::ParenExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnaryOperatorClass == clang::Stmt::UnaryOperatorClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OffsetOfExprClass == clang::Stmt::OffsetOfExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnaryExprOrTypeTraitExprClass == clang::Stmt::UnaryExprOrTypeTraitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ArraySubscriptExprClass == clang::Stmt::ArraySubscriptExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPArraySectionExprClass == clang::Stmt::OMPArraySectionExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CallExprClass == clang::Stmt::CallExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_MemberExprClass == clang::Stmt::MemberExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_BinaryOperatorClass == clang::Stmt::BinaryOperatorClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CompoundAssignOperatorClass == clang::Stmt::CompoundAssignOperatorClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ConditionalOperatorClass == clang::Stmt::ConditionalOperatorClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_BinaryConditionalOperatorClass == clang::Stmt::BinaryConditionalOperatorClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ImplicitCastExprClass == clang::Stmt::ImplicitCastExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CStyleCastExprClass == clang::Stmt::CStyleCastExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CompoundLiteralExprClass == clang::Stmt::CompoundLiteralExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ExtVectorElementExprClass == clang::Stmt::ExtVectorElementExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_InitListExprClass == clang::Stmt::InitListExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_DesignatedInitExprClass == clang::Stmt::DesignatedInitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_DesignatedInitUpdateExprClass == clang::Stmt::DesignatedInitUpdateExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ImplicitValueInitExprClass == clang::Stmt::ImplicitValueInitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_NoInitExprClass == clang::Stmt::NoInitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ArrayInitLoopExprClass == clang::Stmt::ArrayInitLoopExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ArrayInitIndexExprClass == clang::Stmt::ArrayInitIndexExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ParenListExprClass == clang::Stmt::ParenListExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_VAArgExprClass == clang::Stmt::VAArgExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_GenericSelectionExprClass == clang::Stmt::GenericSelectionExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_PseudoObjectExprClass == clang::Stmt::PseudoObjectExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ConstantExprClass == clang::Stmt::ConstantExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_AtomicExprClass == clang::Stmt::AtomicExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_AddrLabelExprClass == clang::Stmt::AddrLabelExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_StmtExprClass == clang::Stmt::StmtExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ChooseExprClass == clang::Stmt::ChooseExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_GNUNullExprClass == clang::Stmt::GNUNullExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXOperatorCallExprClass == clang::Stmt::CXXOperatorCallExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXMemberCallExprClass == clang::Stmt::CXXMemberCallExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXStaticCastExprClass == clang::Stmt::CXXStaticCastExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDynamicCastExprClass == clang::Stmt::CXXDynamicCastExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXReinterpretCastExprClass == clang::Stmt::CXXReinterpretCastExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXConstCastExprClass == clang::Stmt::CXXConstCastExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXFunctionalCastExprClass == clang::Stmt::CXXFunctionalCastExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXTypeidExprClass == clang::Stmt::CXXTypeidExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_UserDefinedLiteralClass == clang::Stmt::UserDefinedLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXBoolLiteralExprClass == clang::Stmt::CXXBoolLiteralExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXNullPtrLiteralExprClass == clang::Stmt::CXXNullPtrLiteralExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXThisExprClass == clang::Stmt::CXXThisExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXThrowExprClass == clang::Stmt::CXXThrowExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDefaultArgExprClass == clang::Stmt::CXXDefaultArgExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDefaultInitExprClass == clang::Stmt::CXXDefaultInitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXScalarValueInitExprClass == clang::Stmt::CXXScalarValueInitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXStdInitializerListExprClass == clang::Stmt::CXXStdInitializerListExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXNewExprClass == clang::Stmt::CXXNewExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDeleteExprClass == clang::Stmt::CXXDeleteExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXPseudoDestructorExprClass == clang::Stmt::CXXPseudoDestructorExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_TypeTraitExprClass == clang::Stmt::TypeTraitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ArrayTypeTraitExprClass == clang::Stmt::ArrayTypeTraitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ExpressionTraitExprClass == clang::Stmt::ExpressionTraitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_DependentScopeDeclRefExprClass == clang::Stmt::DependentScopeDeclRefExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXConstructExprClass == clang::Stmt::CXXConstructExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXInheritedCtorInitExprClass == clang::Stmt::CXXInheritedCtorInitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXBindTemporaryExprClass == clang::Stmt::CXXBindTemporaryExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ExprWithCleanupsClass == clang::Stmt::ExprWithCleanupsClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXTemporaryObjectExprClass == clang::Stmt::CXXTemporaryObjectExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXUnresolvedConstructExprClass == clang::Stmt::CXXUnresolvedConstructExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDependentScopeMemberExprClass == clang::Stmt::CXXDependentScopeMemberExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnresolvedLookupExprClass == clang::Stmt::UnresolvedLookupExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnresolvedMemberExprClass == clang::Stmt::UnresolvedMemberExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXNoexceptExprClass == clang::Stmt::CXXNoexceptExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_PackExpansionExprClass == clang::Stmt::PackExpansionExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SizeOfPackExprClass == clang::Stmt::SizeOfPackExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SubstNonTypeTemplateParmExprClass == clang::Stmt::SubstNonTypeTemplateParmExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SubstNonTypeTemplateParmPackExprClass == clang::Stmt::SubstNonTypeTemplateParmPackExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_FunctionParmPackExprClass == clang::Stmt::FunctionParmPackExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_MaterializeTemporaryExprClass == clang::Stmt::MaterializeTemporaryExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_LambdaExprClass == clang::Stmt::LambdaExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXFoldExprClass == clang::Stmt::CXXFoldExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CoawaitExprClass == clang::Stmt::CoawaitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_DependentCoawaitExprClass == clang::Stmt::DependentCoawaitExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CoyieldExprClass == clang::Stmt::CoyieldExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCStringLiteralClass == clang::Stmt::ObjCStringLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCBoxedExprClass == clang::Stmt::ObjCBoxedExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCArrayLiteralClass == clang::Stmt::ObjCArrayLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCDictionaryLiteralClass == clang::Stmt::ObjCDictionaryLiteralClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCEncodeExprClass == clang::Stmt::ObjCEncodeExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCMessageExprClass == clang::Stmt::ObjCMessageExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCSelectorExprClass == clang::Stmt::ObjCSelectorExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCProtocolExprClass == clang::Stmt::ObjCProtocolExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCIvarRefExprClass == clang::Stmt::ObjCIvarRefExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCPropertyRefExprClass == clang::Stmt::ObjCPropertyRefExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCIsaExprClass == clang::Stmt::ObjCIsaExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCIndirectCopyRestoreExprClass == clang::Stmt::ObjCIndirectCopyRestoreExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCBoolLiteralExprClass == clang::Stmt::ObjCBoolLiteralExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCSubscriptRefExprClass == clang::Stmt::ObjCSubscriptRefExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAvailabilityCheckExprClass == clang::Stmt::ObjCAvailabilityCheckExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCBridgedCastExprClass == clang::Stmt::ObjCBridgedCastExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CUDAKernelCallExprClass == clang::Stmt::CUDAKernelCallExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ShuffleVectorExprClass == clang::Stmt::ShuffleVectorExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_ConvertVectorExprClass == clang::Stmt::ConvertVectorExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_BlockExprClass == clang::Stmt::BlockExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OpaqueValueExprClass == clang::Stmt::OpaqueValueExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_TypoExprClass == clang::Stmt::TypoExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSPropertyRefExprClass == clang::Stmt::MSPropertyRefExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSPropertySubscriptExprClass == clang::Stmt::MSPropertySubscriptExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXUuidofExprClass == clang::Stmt::CXXUuidofExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SEHTryStmtClass == clang::Stmt::SEHTryStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SEHExceptStmtClass == clang::Stmt::SEHExceptStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SEHFinallyStmtClass == clang::Stmt::SEHFinallyStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_SEHLeaveStmtClass == clang::Stmt::SEHLeaveStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSDependentExistsStmtClass == clang::Stmt::MSDependentExistsStmtClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_AsTypeExprClass == clang::Stmt::AsTypeExprClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelDirectiveClass == clang::Stmt::OMPParallelDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPSimdDirectiveClass == clang::Stmt::OMPSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPForDirectiveClass == clang::Stmt::OMPForDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPForSimdDirectiveClass == clang::Stmt::OMPForSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPSectionsDirectiveClass == clang::Stmt::OMPSectionsDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPSectionDirectiveClass == clang::Stmt::OMPSectionDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPSingleDirectiveClass == clang::Stmt::OMPSingleDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPMasterDirectiveClass == clang::Stmt::OMPMasterDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCriticalDirectiveClass == clang::Stmt::OMPCriticalDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelForDirectiveClass == clang::Stmt::OMPParallelForDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelForSimdDirectiveClass == clang::Stmt::OMPParallelForSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelSectionsDirectiveClass == clang::Stmt::OMPParallelSectionsDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskDirectiveClass == clang::Stmt::OMPTaskDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskyieldDirectiveClass == clang::Stmt::OMPTaskyieldDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPBarrierDirectiveClass == clang::Stmt::OMPBarrierDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskwaitDirectiveClass == clang::Stmt::OMPTaskwaitDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskgroupDirectiveClass == clang::Stmt::OMPTaskgroupDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPFlushDirectiveClass == clang::Stmt::OMPFlushDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPOrderedDirectiveClass == clang::Stmt::OMPOrderedDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPAtomicDirectiveClass == clang::Stmt::OMPAtomicDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetDirectiveClass == clang::Stmt::OMPTargetDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetDataDirectiveClass == clang::Stmt::OMPTargetDataDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetEnterDataDirectiveClass == clang::Stmt::OMPTargetEnterDataDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetExitDataDirectiveClass == clang::Stmt::OMPTargetExitDataDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetParallelDirectiveClass == clang::Stmt::OMPTargetParallelDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetParallelForDirectiveClass == clang::Stmt::OMPTargetParallelForDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetUpdateDirectiveClass == clang::Stmt::OMPTargetUpdateDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDirectiveClass == clang::Stmt::OMPTeamsDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCancellationPointDirectiveClass == clang::Stmt::OMPCancellationPointDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCancelDirectiveClass == clang::Stmt::OMPCancelDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskLoopDirectiveClass == clang::Stmt::OMPTaskLoopDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskLoopSimdDirectiveClass == clang::Stmt::OMPTaskLoopSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeDirectiveClass == clang::Stmt::OMPDistributeDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeParallelForDirectiveClass == clang::Stmt::OMPDistributeParallelForDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPDistributeParallelForSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeSimdDirectiveClass == clang::Stmt::OMPDistributeSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetParallelForSimdDirectiveClass == clang::Stmt::OMPTargetParallelForSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetSimdDirectiveClass == clang::Stmt::OMPTargetSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeDirectiveClass == clang::Stmt::OMPTeamsDistributeDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass == clang::Stmt::OMPTeamsDistributeSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass == clang::Stmt::OMPTeamsDistributeParallelForDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDirectiveClass == clang::Stmt::OMPTargetTeamsDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass, "");
+static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeSimdDirectiveClass, "");
+
+void ZigClang_detect_enum_APValueKind(clang::APValue::ValueKind x) {
+    switch (x) {
+        case clang::APValue::Uninitialized:
+        case clang::APValue::Int:
+        case clang::APValue::Float:
+        case clang::APValue::ComplexInt:
+        case clang::APValue::ComplexFloat:
+        case clang::APValue::LValue:
+        case clang::APValue::Vector:
+        case clang::APValue::Array:
+        case clang::APValue::Struct:
+        case clang::APValue::Union:
+        case clang::APValue::MemberPointer:
+        case clang::APValue::AddrLabelDiff:
+            break;
+    }
+}
+
+static_assert((clang::APValue::ValueKind)ZigClangAPValueUninitialized == clang::APValue::Uninitialized, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueInt == clang::APValue::Int, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueFloat == clang::APValue::Float, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueComplexInt == clang::APValue::ComplexInt, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueComplexFloat == clang::APValue::ComplexFloat, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueLValue == clang::APValue::LValue, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueVector == clang::APValue::Vector, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueArray == clang::APValue::Array, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueStruct == clang::APValue::Struct, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueUnion == clang::APValue::Union, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueMemberPointer == clang::APValue::MemberPointer, "");
+static_assert((clang::APValue::ValueKind)ZigClangAPValueAddrLabelDiff == clang::APValue::AddrLabelDiff, "");
+
+
+void ZigClang_detect_enum_DeclKind(clang::Decl::Kind x) {
+    switch (x) {
+        case clang::Decl::AccessSpec:
+        case clang::Decl::Block:
+        case clang::Decl::Captured:
+        case clang::Decl::ClassScopeFunctionSpecialization:
+        case clang::Decl::Empty:
+        case clang::Decl::Export:
+        case clang::Decl::ExternCContext:
+        case clang::Decl::FileScopeAsm:
+        case clang::Decl::Friend:
+        case clang::Decl::FriendTemplate:
+        case clang::Decl::Import:
+        case clang::Decl::LinkageSpec:
+        case clang::Decl::Label:
+        case clang::Decl::Namespace:
+        case clang::Decl::NamespaceAlias:
+        case clang::Decl::ObjCCompatibleAlias:
+        case clang::Decl::ObjCCategory:
+        case clang::Decl::ObjCCategoryImpl:
+        case clang::Decl::ObjCImplementation:
+        case clang::Decl::ObjCInterface:
+        case clang::Decl::ObjCProtocol:
+        case clang::Decl::ObjCMethod:
+        case clang::Decl::ObjCProperty:
+        case clang::Decl::BuiltinTemplate:
+        case clang::Decl::ClassTemplate:
+        case clang::Decl::FunctionTemplate:
+        case clang::Decl::TypeAliasTemplate:
+        case clang::Decl::VarTemplate:
+        case clang::Decl::TemplateTemplateParm:
+        case clang::Decl::Enum:
+        case clang::Decl::Record:
+        case clang::Decl::CXXRecord:
+        case clang::Decl::ClassTemplateSpecialization:
+        case clang::Decl::ClassTemplatePartialSpecialization:
+        case clang::Decl::TemplateTypeParm:
+        case clang::Decl::ObjCTypeParam:
+        case clang::Decl::TypeAlias:
+        case clang::Decl::Typedef:
+        case clang::Decl::UnresolvedUsingTypename:
+        case clang::Decl::Using:
+        case clang::Decl::UsingDirective:
+        case clang::Decl::UsingPack:
+        case clang::Decl::UsingShadow:
+        case clang::Decl::ConstructorUsingShadow:
+        case clang::Decl::Binding:
+        case clang::Decl::Field:
+        case clang::Decl::ObjCAtDefsField:
+        case clang::Decl::ObjCIvar:
+        case clang::Decl::Function:
+        case clang::Decl::CXXDeductionGuide:
+        case clang::Decl::CXXMethod:
+        case clang::Decl::CXXConstructor:
+        case clang::Decl::CXXConversion:
+        case clang::Decl::CXXDestructor:
+        case clang::Decl::MSProperty:
+        case clang::Decl::NonTypeTemplateParm:
+        case clang::Decl::Var:
+        case clang::Decl::Decomposition:
+        case clang::Decl::ImplicitParam:
+        case clang::Decl::OMPCapturedExpr:
+        case clang::Decl::ParmVar:
+        case clang::Decl::VarTemplateSpecialization:
+        case clang::Decl::VarTemplatePartialSpecialization:
+        case clang::Decl::EnumConstant:
+        case clang::Decl::IndirectField:
+        case clang::Decl::OMPDeclareReduction:
+        case clang::Decl::UnresolvedUsingValue:
+        case clang::Decl::OMPRequires:
+        case clang::Decl::OMPThreadPrivate:
+        case clang::Decl::ObjCPropertyImpl:
+        case clang::Decl::PragmaComment:
+        case clang::Decl::PragmaDetectMismatch:
+        case clang::Decl::StaticAssert:
+        case clang::Decl::TranslationUnit:
+            break;
+    }
+}
+
+static_assert((clang::Decl::Kind)ZigClangDeclAccessSpec == clang::Decl::AccessSpec, "");
+static_assert((clang::Decl::Kind)ZigClangDeclBlock == clang::Decl::Block, "");
+static_assert((clang::Decl::Kind)ZigClangDeclCaptured == clang::Decl::Captured, "");
+static_assert((clang::Decl::Kind)ZigClangDeclClassScopeFunctionSpecialization == clang::Decl::ClassScopeFunctionSpecialization, "");
+static_assert((clang::Decl::Kind)ZigClangDeclEmpty == clang::Decl::Empty, "");
+static_assert((clang::Decl::Kind)ZigClangDeclExport == clang::Decl::Export, "");
+static_assert((clang::Decl::Kind)ZigClangDeclExternCContext == clang::Decl::ExternCContext, "");
+static_assert((clang::Decl::Kind)ZigClangDeclFileScopeAsm == clang::Decl::FileScopeAsm, "");
+static_assert((clang::Decl::Kind)ZigClangDeclFriend == clang::Decl::Friend, "");
+static_assert((clang::Decl::Kind)ZigClangDeclFriendTemplate == clang::Decl::FriendTemplate, "");
+static_assert((clang::Decl::Kind)ZigClangDeclImport == clang::Decl::Import, "");
+static_assert((clang::Decl::Kind)ZigClangDeclLinkageSpec == clang::Decl::LinkageSpec, "");
+static_assert((clang::Decl::Kind)ZigClangDeclLabel == clang::Decl::Label, "");
+static_assert((clang::Decl::Kind)ZigClangDeclNamespace == clang::Decl::Namespace, "");
+static_assert((clang::Decl::Kind)ZigClangDeclNamespaceAlias == clang::Decl::NamespaceAlias, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCCompatibleAlias == clang::Decl::ObjCCompatibleAlias, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCCategory == clang::Decl::ObjCCategory, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCCategoryImpl == clang::Decl::ObjCCategoryImpl, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCImplementation == clang::Decl::ObjCImplementation, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCInterface == clang::Decl::ObjCInterface, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCProtocol == clang::Decl::ObjCProtocol, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCMethod == clang::Decl::ObjCMethod, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCProperty == clang::Decl::ObjCProperty, "");
+static_assert((clang::Decl::Kind)ZigClangDeclBuiltinTemplate == clang::Decl::BuiltinTemplate, "");
+static_assert((clang::Decl::Kind)ZigClangDeclClassTemplate == clang::Decl::ClassTemplate, "");
+static_assert((clang::Decl::Kind)ZigClangDeclFunctionTemplate == clang::Decl::FunctionTemplate, "");
+static_assert((clang::Decl::Kind)ZigClangDeclTypeAliasTemplate == clang::Decl::TypeAliasTemplate, "");
+static_assert((clang::Decl::Kind)ZigClangDeclVarTemplate == clang::Decl::VarTemplate, "");
+static_assert((clang::Decl::Kind)ZigClangDeclTemplateTemplateParm == clang::Decl::TemplateTemplateParm, "");
+static_assert((clang::Decl::Kind)ZigClangDeclEnum == clang::Decl::Enum, "");
+static_assert((clang::Decl::Kind)ZigClangDeclRecord == clang::Decl::Record, "");
+static_assert((clang::Decl::Kind)ZigClangDeclCXXRecord == clang::Decl::CXXRecord, "");
+static_assert((clang::Decl::Kind)ZigClangDeclClassTemplateSpecialization == clang::Decl::ClassTemplateSpecialization, "");
+static_assert((clang::Decl::Kind)ZigClangDeclClassTemplatePartialSpecialization == clang::Decl::ClassTemplatePartialSpecialization, "");
+static_assert((clang::Decl::Kind)ZigClangDeclTemplateTypeParm == clang::Decl::TemplateTypeParm, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCTypeParam == clang::Decl::ObjCTypeParam, "");
+static_assert((clang::Decl::Kind)ZigClangDeclTypeAlias == clang::Decl::TypeAlias, "");
+static_assert((clang::Decl::Kind)ZigClangDeclTypedef == clang::Decl::Typedef, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUnresolvedUsingTypename == clang::Decl::UnresolvedUsingTypename, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUsing == clang::Decl::Using, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUsingDirective == clang::Decl::UsingDirective, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUsingPack == clang::Decl::UsingPack, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUsingShadow == clang::Decl::UsingShadow, "");
+static_assert((clang::Decl::Kind)ZigClangDeclConstructorUsingShadow == clang::Decl::ConstructorUsingShadow, "");
+static_assert((clang::Decl::Kind)ZigClangDeclBinding == clang::Decl::Binding, "");
+static_assert((clang::Decl::Kind)ZigClangDeclField == clang::Decl::Field, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCAtDefsField == clang::Decl::ObjCAtDefsField, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCIvar == clang::Decl::ObjCIvar, "");
+static_assert((clang::Decl::Kind)ZigClangDeclFunction == clang::Decl::Function, "");
+static_assert((clang::Decl::Kind)ZigClangDeclCXXDeductionGuide == clang::Decl::CXXDeductionGuide, "");
+static_assert((clang::Decl::Kind)ZigClangDeclCXXMethod == clang::Decl::CXXMethod, "");
+static_assert((clang::Decl::Kind)ZigClangDeclCXXConstructor == clang::Decl::CXXConstructor, "");
+static_assert((clang::Decl::Kind)ZigClangDeclCXXConversion == clang::Decl::CXXConversion, "");
+static_assert((clang::Decl::Kind)ZigClangDeclCXXDestructor == clang::Decl::CXXDestructor, "");
+static_assert((clang::Decl::Kind)ZigClangDeclMSProperty == clang::Decl::MSProperty, "");
+static_assert((clang::Decl::Kind)ZigClangDeclNonTypeTemplateParm == clang::Decl::NonTypeTemplateParm, "");
+static_assert((clang::Decl::Kind)ZigClangDeclVar == clang::Decl::Var, "");
+static_assert((clang::Decl::Kind)ZigClangDeclDecomposition == clang::Decl::Decomposition, "");
+static_assert((clang::Decl::Kind)ZigClangDeclImplicitParam == clang::Decl::ImplicitParam, "");
+static_assert((clang::Decl::Kind)ZigClangDeclOMPCapturedExpr == clang::Decl::OMPCapturedExpr, "");
+static_assert((clang::Decl::Kind)ZigClangDeclParmVar == clang::Decl::ParmVar, "");
+static_assert((clang::Decl::Kind)ZigClangDeclVarTemplateSpecialization == clang::Decl::VarTemplateSpecialization, "");
+static_assert((clang::Decl::Kind)ZigClangDeclVarTemplatePartialSpecialization == clang::Decl::VarTemplatePartialSpecialization, "");
+static_assert((clang::Decl::Kind)ZigClangDeclEnumConstant == clang::Decl::EnumConstant, "");
+static_assert((clang::Decl::Kind)ZigClangDeclIndirectField == clang::Decl::IndirectField, "");
+static_assert((clang::Decl::Kind)ZigClangDeclOMPDeclareReduction == clang::Decl::OMPDeclareReduction, "");
+static_assert((clang::Decl::Kind)ZigClangDeclUnresolvedUsingValue == clang::Decl::UnresolvedUsingValue, "");
+static_assert((clang::Decl::Kind)ZigClangDeclOMPRequires == clang::Decl::OMPRequires, "");
+static_assert((clang::Decl::Kind)ZigClangDeclOMPThreadPrivate == clang::Decl::OMPThreadPrivate, "");
+static_assert((clang::Decl::Kind)ZigClangDeclObjCPropertyImpl == clang::Decl::ObjCPropertyImpl, "");
+static_assert((clang::Decl::Kind)ZigClangDeclPragmaComment == clang::Decl::PragmaComment, "");
+static_assert((clang::Decl::Kind)ZigClangDeclPragmaDetectMismatch == clang::Decl::PragmaDetectMismatch, "");
+static_assert((clang::Decl::Kind)ZigClangDeclStaticAssert == clang::Decl::StaticAssert, "");
+static_assert((clang::Decl::Kind)ZigClangDeclTranslationUnit == clang::Decl::TranslationUnit, "");
+
+void ZigClang_detect_enum_BuiltinTypeKind(clang::BuiltinType::Kind x) {
+    switch (x) {
+        case clang::BuiltinType::OCLImage1dRO:
+        case clang::BuiltinType::OCLImage1dArrayRO:
+        case clang::BuiltinType::OCLImage1dBufferRO:
+        case clang::BuiltinType::OCLImage2dRO:
+        case clang::BuiltinType::OCLImage2dArrayRO:
+        case clang::BuiltinType::OCLImage2dDepthRO:
+        case clang::BuiltinType::OCLImage2dArrayDepthRO:
+        case clang::BuiltinType::OCLImage2dMSAARO:
+        case clang::BuiltinType::OCLImage2dArrayMSAARO:
+        case clang::BuiltinType::OCLImage2dMSAADepthRO:
+        case clang::BuiltinType::OCLImage2dArrayMSAADepthRO:
+        case clang::BuiltinType::OCLImage3dRO:
+        case clang::BuiltinType::OCLImage1dWO:
+        case clang::BuiltinType::OCLImage1dArrayWO:
+        case clang::BuiltinType::OCLImage1dBufferWO:
+        case clang::BuiltinType::OCLImage2dWO:
+        case clang::BuiltinType::OCLImage2dArrayWO:
+        case clang::BuiltinType::OCLImage2dDepthWO:
+        case clang::BuiltinType::OCLImage2dArrayDepthWO:
+        case clang::BuiltinType::OCLImage2dMSAAWO:
+        case clang::BuiltinType::OCLImage2dArrayMSAAWO:
+        case clang::BuiltinType::OCLImage2dMSAADepthWO:
+        case clang::BuiltinType::OCLImage2dArrayMSAADepthWO:
+        case clang::BuiltinType::OCLImage3dWO:
+        case clang::BuiltinType::OCLImage1dRW:
+        case clang::BuiltinType::OCLImage1dArrayRW:
+        case clang::BuiltinType::OCLImage1dBufferRW:
+        case clang::BuiltinType::OCLImage2dRW:
+        case clang::BuiltinType::OCLImage2dArrayRW:
+        case clang::BuiltinType::OCLImage2dDepthRW:
+        case clang::BuiltinType::OCLImage2dArrayDepthRW:
+        case clang::BuiltinType::OCLImage2dMSAARW:
+        case clang::BuiltinType::OCLImage2dArrayMSAARW:
+        case clang::BuiltinType::OCLImage2dMSAADepthRW:
+        case clang::BuiltinType::OCLImage2dArrayMSAADepthRW:
+        case clang::BuiltinType::OCLImage3dRW:
+        case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload:
+        case clang::BuiltinType::OCLIntelSubgroupAVCImePayload:
+        case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload:
+        case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload:
+        case clang::BuiltinType::OCLIntelSubgroupAVCMceResult:
+        case clang::BuiltinType::OCLIntelSubgroupAVCImeResult:
+        case clang::BuiltinType::OCLIntelSubgroupAVCRefResult:
+        case clang::BuiltinType::OCLIntelSubgroupAVCSicResult:
+        case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout:
+        case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout:
+        case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin:
+        case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin:
+        case clang::BuiltinType::Void:
+        case clang::BuiltinType::Bool:
+        case clang::BuiltinType::Char_U:
+        case clang::BuiltinType::UChar:
+        case clang::BuiltinType::WChar_U:
+        case clang::BuiltinType::Char8:
+        case clang::BuiltinType::Char16:
+        case clang::BuiltinType::Char32:
+        case clang::BuiltinType::UShort:
+        case clang::BuiltinType::UInt:
+        case clang::BuiltinType::ULong:
+        case clang::BuiltinType::ULongLong:
+        case clang::BuiltinType::UInt128:
+        case clang::BuiltinType::Char_S:
+        case clang::BuiltinType::SChar:
+        case clang::BuiltinType::WChar_S:
+        case clang::BuiltinType::Short:
+        case clang::BuiltinType::Int:
+        case clang::BuiltinType::Long:
+        case clang::BuiltinType::LongLong:
+        case clang::BuiltinType::Int128:
+        case clang::BuiltinType::ShortAccum:
+        case clang::BuiltinType::Accum:
+        case clang::BuiltinType::LongAccum:
+        case clang::BuiltinType::UShortAccum:
+        case clang::BuiltinType::UAccum:
+        case clang::BuiltinType::ULongAccum:
+        case clang::BuiltinType::ShortFract:
+        case clang::BuiltinType::Fract:
+        case clang::BuiltinType::LongFract:
+        case clang::BuiltinType::UShortFract:
+        case clang::BuiltinType::UFract:
+        case clang::BuiltinType::ULongFract:
+        case clang::BuiltinType::SatShortAccum:
+        case clang::BuiltinType::SatAccum:
+        case clang::BuiltinType::SatLongAccum:
+        case clang::BuiltinType::SatUShortAccum:
+        case clang::BuiltinType::SatUAccum:
+        case clang::BuiltinType::SatULongAccum:
+        case clang::BuiltinType::SatShortFract:
+        case clang::BuiltinType::SatFract:
+        case clang::BuiltinType::SatLongFract:
+        case clang::BuiltinType::SatUShortFract:
+        case clang::BuiltinType::SatUFract:
+        case clang::BuiltinType::SatULongFract:
+        case clang::BuiltinType::Half:
+        case clang::BuiltinType::Float:
+        case clang::BuiltinType::Double:
+        case clang::BuiltinType::LongDouble:
+        case clang::BuiltinType::Float16:
+        case clang::BuiltinType::Float128:
+        case clang::BuiltinType::NullPtr:
+        case clang::BuiltinType::ObjCId:
+        case clang::BuiltinType::ObjCClass:
+        case clang::BuiltinType::ObjCSel:
+        case clang::BuiltinType::OCLSampler:
+        case clang::BuiltinType::OCLEvent:
+        case clang::BuiltinType::OCLClkEvent:
+        case clang::BuiltinType::OCLQueue:
+        case clang::BuiltinType::OCLReserveID:
+        case clang::BuiltinType::Dependent:
+        case clang::BuiltinType::Overload:
+        case clang::BuiltinType::BoundMember:
+        case clang::BuiltinType::PseudoObject:
+        case clang::BuiltinType::UnknownAny:
+        case clang::BuiltinType::BuiltinFn:
+        case clang::BuiltinType::ARCUnbridgedCast:
+        case clang::BuiltinType::OMPArraySection:
+            break;
+    }
+}
+
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dRO == clang::BuiltinType::OCLImage1dRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dArrayRO == clang::BuiltinType::OCLImage1dArrayRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dBufferRO == clang::BuiltinType::OCLImage1dBufferRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dRO == clang::BuiltinType::OCLImage2dRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayRO == clang::BuiltinType::OCLImage2dArrayRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dDepthRO == clang::BuiltinType::OCLImage2dDepthRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayDepthRO == clang::BuiltinType::OCLImage2dArrayDepthRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAARO == clang::BuiltinType::OCLImage2dMSAARO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAARO == clang::BuiltinType::OCLImage2dArrayMSAARO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAADepthRO == clang::BuiltinType::OCLImage2dMSAADepthRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRO == clang::BuiltinType::OCLImage2dArrayMSAADepthRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage3dRO == clang::BuiltinType::OCLImage3dRO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dWO == clang::BuiltinType::OCLImage1dWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dArrayWO == clang::BuiltinType::OCLImage1dArrayWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dBufferWO == clang::BuiltinType::OCLImage1dBufferWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dWO == clang::BuiltinType::OCLImage2dWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayWO == clang::BuiltinType::OCLImage2dArrayWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dDepthWO == clang::BuiltinType::OCLImage2dDepthWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayDepthWO == clang::BuiltinType::OCLImage2dArrayDepthWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAAWO == clang::BuiltinType::OCLImage2dMSAAWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAAWO == clang::BuiltinType::OCLImage2dArrayMSAAWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAADepthWO == clang::BuiltinType::OCLImage2dMSAADepthWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAADepthWO == clang::BuiltinType::OCLImage2dArrayMSAADepthWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage3dWO == clang::BuiltinType::OCLImage3dWO, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dRW == clang::BuiltinType::OCLImage1dRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dArrayRW == clang::BuiltinType::OCLImage1dArrayRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dBufferRW == clang::BuiltinType::OCLImage1dBufferRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dRW == clang::BuiltinType::OCLImage2dRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayRW == clang::BuiltinType::OCLImage2dArrayRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dDepthRW == clang::BuiltinType::OCLImage2dDepthRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayDepthRW == clang::BuiltinType::OCLImage2dArrayDepthRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAARW == clang::BuiltinType::OCLImage2dMSAARW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAARW == clang::BuiltinType::OCLImage2dArrayMSAARW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAADepthRW == clang::BuiltinType::OCLImage2dMSAADepthRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRW == clang::BuiltinType::OCLImage2dArrayMSAADepthRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage3dRW == clang::BuiltinType::OCLImage3dRW, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCMcePayload == clang::BuiltinType::OCLIntelSubgroupAVCMcePayload, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImePayload == clang::BuiltinType::OCLIntelSubgroupAVCImePayload, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCRefPayload == clang::BuiltinType::OCLIntelSubgroupAVCRefPayload, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCSicPayload == clang::BuiltinType::OCLIntelSubgroupAVCSicPayload, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCMceResult == clang::BuiltinType::OCLIntelSubgroupAVCMceResult, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResult == clang::BuiltinType::OCLIntelSubgroupAVCImeResult, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCRefResult == clang::BuiltinType::OCLIntelSubgroupAVCRefResult, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCSicResult == clang::BuiltinType::OCLIntelSubgroupAVCSicResult, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultSingleRefStreamout == clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultDualRefStreamout == clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeSingleRefStreamin == clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeDualRefStreamin == clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeVoid == clang::BuiltinType::Void, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBool == clang::BuiltinType::Bool, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar_U == clang::BuiltinType::Char_U, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUChar == clang::BuiltinType::UChar, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeWChar_U == clang::BuiltinType::WChar_U, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar8 == clang::BuiltinType::Char8, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar16 == clang::BuiltinType::Char16, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar32 == clang::BuiltinType::Char32, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUShort == clang::BuiltinType::UShort, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUInt == clang::BuiltinType::UInt, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeULong == clang::BuiltinType::ULong, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeULongLong == clang::BuiltinType::ULongLong, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUInt128 == clang::BuiltinType::UInt128, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar_S == clang::BuiltinType::Char_S, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSChar == clang::BuiltinType::SChar, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeWChar_S == clang::BuiltinType::WChar_S, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeShort == clang::BuiltinType::Short, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeInt == clang::BuiltinType::Int, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLong == clang::BuiltinType::Long, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLongLong == clang::BuiltinType::LongLong, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeInt128 == clang::BuiltinType::Int128, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeShortAccum == clang::BuiltinType::ShortAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeAccum == clang::BuiltinType::Accum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLongAccum == clang::BuiltinType::LongAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUShortAccum == clang::BuiltinType::UShortAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUAccum == clang::BuiltinType::UAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeULongAccum == clang::BuiltinType::ULongAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeShortFract == clang::BuiltinType::ShortFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeFract == clang::BuiltinType::Fract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLongFract == clang::BuiltinType::LongFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUShortFract == clang::BuiltinType::UShortFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUFract == clang::BuiltinType::UFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeULongFract == clang::BuiltinType::ULongFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatShortAccum == clang::BuiltinType::SatShortAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatAccum == clang::BuiltinType::SatAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatLongAccum == clang::BuiltinType::SatLongAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatUShortAccum == clang::BuiltinType::SatUShortAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatUAccum == clang::BuiltinType::SatUAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatULongAccum == clang::BuiltinType::SatULongAccum, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatShortFract == clang::BuiltinType::SatShortFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatFract == clang::BuiltinType::SatFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatLongFract == clang::BuiltinType::SatLongFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatUShortFract == clang::BuiltinType::SatUShortFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatUFract == clang::BuiltinType::SatUFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatULongFract == clang::BuiltinType::SatULongFract, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeHalf == clang::BuiltinType::Half, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeFloat == clang::BuiltinType::Float, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeDouble == clang::BuiltinType::Double, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLongDouble == clang::BuiltinType::LongDouble, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeFloat16 == clang::BuiltinType::Float16, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeFloat128 == clang::BuiltinType::Float128, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeNullPtr == clang::BuiltinType::NullPtr, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeObjCId == clang::BuiltinType::ObjCId, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeObjCClass == clang::BuiltinType::ObjCClass, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeObjCSel == clang::BuiltinType::ObjCSel, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLSampler == clang::BuiltinType::OCLSampler, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLEvent == clang::BuiltinType::OCLEvent, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLClkEvent == clang::BuiltinType::OCLClkEvent, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLQueue == clang::BuiltinType::OCLQueue, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLReserveID == clang::BuiltinType::OCLReserveID, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeDependent == clang::BuiltinType::Dependent, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOverload == clang::BuiltinType::Overload, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBoundMember == clang::BuiltinType::BoundMember, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypePseudoObject == clang::BuiltinType::PseudoObject, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUnknownAny == clang::BuiltinType::UnknownAny, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBuiltinFn == clang::BuiltinType::BuiltinFn, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeARCUnbridgedCast == clang::BuiltinType::ARCUnbridgedCast, "");
+static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOMPArraySection == clang::BuiltinType::OMPArraySection, "");
+
+void ZigClang_detect_enum_CallingConv(clang::CallingConv x) {
+    switch (x) {
+        case clang::CC_C:
+        case clang::CC_X86StdCall:
+        case clang::CC_X86FastCall:
+        case clang::CC_X86ThisCall:
+        case clang::CC_X86VectorCall:
+        case clang::CC_X86Pascal:
+        case clang::CC_Win64:
+        case clang::CC_X86_64SysV:
+        case clang::CC_X86RegCall:
+        case clang::CC_AAPCS:
+        case clang::CC_AAPCS_VFP:
+        case clang::CC_IntelOclBicc:
+        case clang::CC_SpirFunction:
+        case clang::CC_OpenCLKernel:
+        case clang::CC_Swift:
+        case clang::CC_PreserveMost:
+        case clang::CC_PreserveAll:
+        case clang::CC_AArch64VectorCall:
+            break;
+    }
+}
+
+static_assert((clang::CallingConv)ZigClangCallingConv_C == clang::CC_C, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_X86StdCall == clang::CC_X86StdCall, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_X86FastCall == clang::CC_X86FastCall, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_X86ThisCall == clang::CC_X86ThisCall, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_X86VectorCall == clang::CC_X86VectorCall, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_X86Pascal == clang::CC_X86Pascal, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_Win64 == clang::CC_Win64, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_X86_64SysV == clang::CC_X86_64SysV, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_X86RegCall == clang::CC_X86RegCall, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_AAPCS == clang::CC_AAPCS, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_AAPCS_VFP == clang::CC_AAPCS_VFP, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_IntelOclBicc == clang::CC_IntelOclBicc, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_SpirFunction == clang::CC_SpirFunction, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_OpenCLKernel == clang::CC_OpenCLKernel, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_Swift == clang::CC_Swift, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_PreserveMost == clang::CC_PreserveMost, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_PreserveAll == clang::CC_PreserveAll, "");
+static_assert((clang::CallingConv)ZigClangCallingConv_AArch64VectorCall == clang::CC_AArch64VectorCall, "");
+
+void ZigClang_detect_enum_StorageClass(clang::StorageClass x) {
+    switch (x) {
+        case clang::SC_None:
+        case clang::SC_Extern:
+        case clang::SC_Static:
+        case clang::SC_PrivateExtern:
+        case clang::SC_Auto:
+        case clang::SC_Register:
+            break;
+    }
+}
+
+static_assert((clang::StorageClass)ZigClangStorageClass_None == clang::SC_None, "");
+static_assert((clang::StorageClass)ZigClangStorageClass_Extern == clang::SC_Extern, "");
+static_assert((clang::StorageClass)ZigClangStorageClass_Static == clang::SC_Static, "");
+static_assert((clang::StorageClass)ZigClangStorageClass_PrivateExtern == clang::SC_PrivateExtern, "");
+static_assert((clang::StorageClass)ZigClangStorageClass_Auto == clang::SC_Auto, "");
+static_assert((clang::StorageClass)ZigClangStorageClass_Register == clang::SC_Register, "");
+
+
 static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), "");
 static ZigClangSourceLocation bitcast(clang::SourceLocation src) {
     ZigClangSourceLocation dest;
@@ -161,6 +1280,26 @@ static clang::QualType bitcast(ZigClangQualType src) {
     return dest;
 }
 
+static_assert(sizeof(ZigClangAPValueLValueBase) == sizeof(clang::APValue::LValueBase), "");
+static ZigClangAPValueLValueBase bitcast(clang::APValue::LValueBase src) {
+    ZigClangAPValueLValueBase dest;
+    memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangAPValueLValueBase));
+    return dest;
+}
+static clang::APValue::LValueBase bitcast(ZigClangAPValueLValueBase src) {
+    clang::APValue::LValueBase dest;
+    memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangAPValueLValueBase));
+    return dest;
+}
+
+static_assert(sizeof(ZigClangCompoundStmt_const_body_iterator) == sizeof(clang::CompoundStmt::const_body_iterator), "");
+static ZigClangCompoundStmt_const_body_iterator bitcast(clang::CompoundStmt::const_body_iterator src) {
+    ZigClangCompoundStmt_const_body_iterator dest;
+    memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangCompoundStmt_const_body_iterator));
+    return dest;
+}
+
+
 ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const ZigClangSourceManager *self,
         ZigClangSourceLocation Loc)
 {
@@ -196,6 +1335,10 @@ ZigClangQualType ZigClangASTContext_getPointerType(const ZigClangASTContext* sel
     return bitcast(reinterpret_cast<const clang::ASTContext *>(self)->getPointerType(bitcast(T)));
 }
 
+unsigned ZigClangASTContext_getTypeAlign(const ZigClangASTContext* self, ZigClangQualType T) {
+    return reinterpret_cast<const clang::ASTContext *>(self)->getTypeAlign(bitcast(T));
+}
+
 ZigClangASTContext *ZigClangASTUnit_getASTContext(ZigClangASTUnit *self) {
     clang::ASTContext *result = &reinterpret_cast<clang::ASTUnit *>(self)->getASTContext();
     return reinterpret_cast<ZigClangASTContext *>(result);
@@ -212,3 +1355,477 @@ bool ZigClangASTUnit_visitLocalTopLevelDecls(ZigClangASTUnit *self, void *contex
     return reinterpret_cast<clang::ASTUnit *>(self)->visitLocalTopLevelDecls(context,
             reinterpret_cast<bool (*)(void *, const clang::Decl *)>(Fn));
 }
+
+const ZigClangRecordDecl *ZigClangRecordType_getDecl(const ZigClangRecordType *record_ty) {
+    const clang::RecordDecl *record_decl = reinterpret_cast<const clang::RecordType *>(record_ty)->getDecl();
+    return reinterpret_cast<const ZigClangRecordDecl *>(record_decl);
+}
+
+const ZigClangEnumDecl *ZigClangEnumType_getDecl(const ZigClangEnumType *enum_ty) {
+    const clang::EnumDecl *enum_decl = reinterpret_cast<const clang::EnumType *>(enum_ty)->getDecl();
+    return reinterpret_cast<const ZigClangEnumDecl *>(enum_decl);
+}
+
+const ZigClangTagDecl *ZigClangRecordDecl_getCanonicalDecl(const ZigClangRecordDecl *record_decl) {
+    const clang::TagDecl *tag_decl = reinterpret_cast<const clang::RecordDecl*>(record_decl)->getCanonicalDecl();
+    return reinterpret_cast<const ZigClangTagDecl *>(tag_decl);
+}
+
+const ZigClangTagDecl *ZigClangEnumDecl_getCanonicalDecl(const ZigClangEnumDecl *enum_decl) {
+    const clang::TagDecl *tag_decl = reinterpret_cast<const clang::EnumDecl*>(enum_decl)->getCanonicalDecl();
+    return reinterpret_cast<const ZigClangTagDecl *>(tag_decl);
+}
+
+const ZigClangTypedefNameDecl *ZigClangTypedefNameDecl_getCanonicalDecl(const ZigClangTypedefNameDecl *self) {
+    const clang::TypedefNameDecl *decl = reinterpret_cast<const clang::TypedefNameDecl*>(self)->getCanonicalDecl();
+    return reinterpret_cast<const ZigClangTypedefNameDecl *>(decl);
+}
+
+const ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl *zig_record_decl) {
+    const clang::RecordDecl *record_decl = reinterpret_cast<const clang::RecordDecl *>(zig_record_decl);
+    const clang::RecordDecl *definition = record_decl->getDefinition();
+    return reinterpret_cast<const ZigClangRecordDecl *>(definition);
+}
+
+const ZigClangEnumDecl *ZigClangEnumDecl_getDefinition(const ZigClangEnumDecl *zig_enum_decl) {
+    const clang::EnumDecl *enum_decl = reinterpret_cast<const clang::EnumDecl *>(zig_enum_decl);
+    const clang::EnumDecl *definition = enum_decl->getDefinition();
+    return reinterpret_cast<const ZigClangEnumDecl *>(definition);
+}
+
+bool ZigClangRecordDecl_isUnion(const ZigClangRecordDecl *record_decl) {
+    return reinterpret_cast<const clang::RecordDecl*>(record_decl)->isUnion();
+}
+
+bool ZigClangRecordDecl_isStruct(const ZigClangRecordDecl *record_decl) {
+    return reinterpret_cast<const clang::RecordDecl*>(record_decl)->isStruct();
+}
+
+bool ZigClangRecordDecl_isAnonymousStructOrUnion(const ZigClangRecordDecl *record_decl) {
+    return reinterpret_cast<const clang::RecordDecl*>(record_decl)->isAnonymousStructOrUnion();
+}
+
+const char *ZigClangDecl_getName_bytes_begin(const ZigClangDecl *zig_decl) {
+    const clang::Decl *decl = reinterpret_cast<const clang::Decl *>(zig_decl);
+    const clang::NamedDecl *named_decl = static_cast<const clang::NamedDecl *>(decl);
+    return (const char *)named_decl->getName().bytes_begin();
+}
+
+ZigClangDeclKind ZigClangDecl_getKind(const struct ZigClangDecl *self) {
+    auto casted = reinterpret_cast<const clang::Decl *>(self);
+    return (ZigClangDeclKind)casted->getKind();
+}
+
+const char *ZigClangDecl_getDeclKindName(const struct ZigClangDecl *self) {
+    auto casted = reinterpret_cast<const clang::Decl *>(self);
+    return casted->getDeclKindName();
+}
+
+ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl *zig_record_decl) {
+    const clang::RecordDecl *record_decl = reinterpret_cast<const clang::RecordDecl *>(zig_record_decl);
+    return bitcast(record_decl->getLocation());
+}
+
+ZigClangSourceLocation ZigClangEnumDecl_getLocation(const ZigClangEnumDecl *self) {
+    auto casted = reinterpret_cast<const clang::EnumDecl *>(self);
+    return bitcast(casted->getLocation());
+}
+
+ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const ZigClangTypedefNameDecl *self) {
+    auto casted = reinterpret_cast<const clang::TypedefNameDecl *>(self);
+    return bitcast(casted->getLocation());
+}
+
+ZigClangSourceLocation ZigClangDecl_getLocation(const ZigClangDecl *self) {
+    auto casted = reinterpret_cast<const clang::Decl *>(self);
+    return bitcast(casted->getLocation());
+}
+
+bool ZigClangSourceLocation_eq(ZigClangSourceLocation zig_a, ZigClangSourceLocation zig_b) {
+    clang::SourceLocation a = bitcast(zig_a);
+    clang::SourceLocation b = bitcast(zig_b);
+    return a == b;
+}
+
+ZigClangQualType ZigClangEnumDecl_getIntegerType(const ZigClangEnumDecl *self) {
+    return bitcast(reinterpret_cast<const clang::EnumDecl *>(self)->getIntegerType());
+}
+
+struct ZigClangQualType ZigClangFunctionDecl_getType(const struct ZigClangFunctionDecl *self) {
+    auto casted = reinterpret_cast<const clang::FunctionDecl *>(self);
+    return bitcast(casted->getType());
+}
+
+struct ZigClangSourceLocation ZigClangFunctionDecl_getLocation(const struct ZigClangFunctionDecl *self) {
+    auto casted = reinterpret_cast<const clang::FunctionDecl *>(self);
+    return bitcast(casted->getLocation());
+}
+
+bool ZigClangFunctionDecl_hasBody(const struct ZigClangFunctionDecl *self) {
+    auto casted = reinterpret_cast<const clang::FunctionDecl *>(self);
+    return casted->hasBody();
+}
+
+enum ZigClangStorageClass ZigClangFunctionDecl_getStorageClass(const struct ZigClangFunctionDecl *self) {
+    auto casted = reinterpret_cast<const clang::FunctionDecl *>(self);
+    return (ZigClangStorageClass)casted->getStorageClass();
+}
+
+const struct ZigClangParmVarDecl *ZigClangFunctionDecl_getParamDecl(const struct ZigClangFunctionDecl *self,
+        unsigned i)
+{
+    auto casted = reinterpret_cast<const clang::FunctionDecl *>(self);
+    const clang::ParmVarDecl *parm_var_decl = casted->getParamDecl(i);
+    return reinterpret_cast<const ZigClangParmVarDecl *>(parm_var_decl);
+}
+
+const struct ZigClangStmt *ZigClangFunctionDecl_getBody(const struct ZigClangFunctionDecl *self) {
+    auto casted = reinterpret_cast<const clang::FunctionDecl *>(self);
+    const clang::Stmt *stmt = casted->getBody();
+    return reinterpret_cast<const ZigClangStmt *>(stmt);
+}
+
+const ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const ZigClangTypedefType *self) {
+    auto casted = reinterpret_cast<const clang::TypedefType *>(self);
+    const clang::TypedefNameDecl *name_decl = casted->getDecl();
+    return reinterpret_cast<const ZigClangTypedefNameDecl *>(name_decl);
+}
+
+ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedefNameDecl *self) {
+    auto casted = reinterpret_cast<const clang::TypedefNameDecl *>(self);
+    clang::QualType ty = casted->getUnderlyingType();
+    return bitcast(ty);
+}
+
+ZigClangQualType ZigClangQualType_getCanonicalType(ZigClangQualType self) {
+    clang::QualType qt = bitcast(self);
+    return bitcast(qt.getCanonicalType());
+}
+
+const ZigClangType *ZigClangQualType_getTypePtr(ZigClangQualType self) {
+    clang::QualType qt = bitcast(self);
+    const clang::Type *ty = qt.getTypePtr();
+    return reinterpret_cast<const ZigClangType *>(ty);
+}
+
+void ZigClangQualType_addConst(ZigClangQualType *self) {
+    reinterpret_cast<clang::QualType *>(self)->addConst();
+}
+
+bool ZigClangQualType_eq(ZigClangQualType zig_t1, ZigClangQualType zig_t2) {
+    clang::QualType t1 = bitcast(zig_t1);
+    clang::QualType t2 = bitcast(zig_t2);
+    if (t1.isConstQualified() != t2.isConstQualified()) {
+        return false;
+    }
+    if (t1.isVolatileQualified() != t2.isVolatileQualified()) {
+        return false;
+    }
+    if (t1.isRestrictQualified() != t2.isRestrictQualified()) {
+        return false;
+    }
+    return t1.getTypePtr() == t2.getTypePtr();
+}
+
+bool ZigClangQualType_isConstQualified(ZigClangQualType self) {
+    clang::QualType qt = bitcast(self);
+    return qt.isConstQualified();
+}
+
+bool ZigClangQualType_isVolatileQualified(ZigClangQualType self) {
+    clang::QualType qt = bitcast(self);
+    return qt.isVolatileQualified();
+}
+
+bool ZigClangQualType_isRestrictQualified(ZigClangQualType self) {
+    clang::QualType qt = bitcast(self);
+    return qt.isRestrictQualified();
+}
+
+ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self) {
+    auto casted = reinterpret_cast<const clang::Type *>(self);
+    clang::Type::TypeClass tc = casted->getTypeClass();
+    return (ZigClangTypeClass)tc;
+}
+
+ZigClangQualType ZigClangType_getPointeeType(const ZigClangType *self) {
+    auto casted = reinterpret_cast<const clang::Type *>(self);
+    return bitcast(casted->getPointeeType());
+}
+
+bool ZigClangType_isVoidType(const ZigClangType *self) {
+    auto casted = reinterpret_cast<const clang::Type *>(self);
+    return casted->isVoidType();
+}
+
+const char *ZigClangType_getTypeClassName(const ZigClangType *self) {
+    auto casted = reinterpret_cast<const clang::Type *>(self);
+    return casted->getTypeClassName();
+}
+
+ZigClangSourceLocation ZigClangStmt_getBeginLoc(const ZigClangStmt *self) {
+    auto casted = reinterpret_cast<const clang::Stmt *>(self);
+    return bitcast(casted->getBeginLoc());
+}
+
+bool ZigClangStmt_classof_Expr(const ZigClangStmt *self) {
+    auto casted = reinterpret_cast<const clang::Stmt *>(self);
+    return clang::Expr::classof(casted);
+}
+
+ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self) {
+    auto casted = reinterpret_cast<const clang::Stmt *>(self);
+    return (ZigClangStmtClass)casted->getStmtClass();
+}
+
+ZigClangStmtClass ZigClangExpr_getStmtClass(const ZigClangExpr *self) {
+    auto casted = reinterpret_cast<const clang::Expr *>(self);
+    return (ZigClangStmtClass)casted->getStmtClass();
+}
+
+ZigClangQualType ZigClangExpr_getType(const ZigClangExpr *self) {
+    auto casted = reinterpret_cast<const clang::Expr *>(self);
+    return bitcast(casted->getType());
+}
+
+ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self) {
+    auto casted = reinterpret_cast<const clang::Expr *>(self);
+    return bitcast(casted->getBeginLoc());
+}
+
+ZigClangAPValueKind ZigClangAPValue_getKind(const ZigClangAPValue *self) {
+    auto casted = reinterpret_cast<const clang::APValue *>(self);
+    return (ZigClangAPValueKind)casted->getKind();
+}
+
+const ZigClangAPSInt *ZigClangAPValue_getInt(const ZigClangAPValue *self) {
+    auto casted = reinterpret_cast<const clang::APValue *>(self);
+    const llvm::APSInt *result = &casted->getInt();
+    return reinterpret_cast<const ZigClangAPSInt *>(result);
+}
+
+unsigned ZigClangAPValue_getArrayInitializedElts(const ZigClangAPValue *self) {
+    auto casted = reinterpret_cast<const clang::APValue *>(self);
+    return casted->getArrayInitializedElts();
+}
+
+const ZigClangAPValue *ZigClangAPValue_getArrayInitializedElt(const ZigClangAPValue *self, unsigned i) {
+    auto casted = reinterpret_cast<const clang::APValue *>(self);
+    const clang::APValue *result = &casted->getArrayInitializedElt(i);
+    return reinterpret_cast<const ZigClangAPValue *>(result);
+}
+
+const ZigClangAPValue *ZigClangAPValue_getArrayFiller(const ZigClangAPValue *self) {
+    auto casted = reinterpret_cast<const clang::APValue *>(self);
+    const clang::APValue *result = &casted->getArrayFiller();
+    return reinterpret_cast<const ZigClangAPValue *>(result);
+}
+
+unsigned ZigClangAPValue_getArraySize(const ZigClangAPValue *self) {
+    auto casted = reinterpret_cast<const clang::APValue *>(self);
+    return casted->getArraySize();
+}
+
+const ZigClangAPSInt *ZigClangAPSInt_negate(const ZigClangAPSInt *self) {
+    auto casted = reinterpret_cast<const llvm::APSInt *>(self);
+    llvm::APSInt *result = new llvm::APSInt();
+    *result = *casted;
+    *result = -*result;
+    return reinterpret_cast<const ZigClangAPSInt *>(result);
+}
+
+void ZigClangAPSInt_free(const ZigClangAPSInt *self) {
+    auto casted = reinterpret_cast<const llvm::APSInt *>(self);
+    delete casted;
+}
+
+bool ZigClangAPSInt_isSigned(const ZigClangAPSInt *self) {
+    auto casted = reinterpret_cast<const llvm::APSInt *>(self);
+    return casted->isSigned();
+}
+
+bool ZigClangAPSInt_isNegative(const ZigClangAPSInt *self) {
+    auto casted = reinterpret_cast<const llvm::APSInt *>(self);
+    return casted->isNegative();
+}
+
+const uint64_t *ZigClangAPSInt_getRawData(const ZigClangAPSInt *self) {
+    auto casted = reinterpret_cast<const llvm::APSInt *>(self);
+    return casted->getRawData();
+}
+
+unsigned ZigClangAPSInt_getNumWords(const ZigClangAPSInt *self) {
+    auto casted = reinterpret_cast<const llvm::APSInt *>(self);
+    return casted->getNumWords();
+}
+
+const ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(ZigClangAPValueLValueBase self) {
+    clang::APValue::LValueBase casted = bitcast(self);
+    const clang::Expr *expr = casted.dyn_cast<const clang::Expr *>();
+    return reinterpret_cast<const ZigClangExpr *>(expr);
+}
+
+ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const ZigClangAPValue *self) {
+    auto casted = reinterpret_cast<const clang::APValue *>(self);
+    clang::APValue::LValueBase lval_base = casted->getLValueBase();
+    return bitcast(lval_base);
+}
+
+ZigClangASTUnit *ZigClangLoadFromCommandLine(const char **args_begin, const char **args_end,
+    struct Stage2ErrorMsg **errors_ptr, size_t *errors_len, const char *resources_path)
+{
+    clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions));
+
+    std::shared_ptr<clang::PCHContainerOperations> pch_container_ops = std::make_shared<clang::PCHContainerOperations>();
+
+    bool only_local_decls = true;
+    bool capture_diagnostics = true;
+    bool user_files_are_volatile = true;
+    bool allow_pch_with_compiler_errors = false;
+    bool single_file_parse = false;
+    bool for_serialization = false;
+    std::unique_ptr<clang::ASTUnit> *err_unit = new std::unique_ptr<clang::ASTUnit>();
+    clang::ASTUnit *ast_unit = clang::ASTUnit::LoadFromCommandLine(
+            args_begin, args_end,
+            pch_container_ops, diags, resources_path,
+            only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete,
+            false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None,
+            single_file_parse, user_files_are_volatile, for_serialization, clang::None, err_unit,
+            nullptr);
+
+    // Early failures in LoadFromCommandLine may return with ErrUnit unset.
+    if (!ast_unit && !err_unit) {
+        return nullptr;
+    }
+
+    if (diags->getClient()->getNumErrors() > 0) {
+        if (ast_unit) {
+            *err_unit = std::unique_ptr<clang::ASTUnit>(ast_unit);
+        }
+
+        size_t cap = 4;
+        *errors_len = 0;
+        *errors_ptr = reinterpret_cast<Stage2ErrorMsg*>(malloc(cap * sizeof(Stage2ErrorMsg)));
+        if (*errors_ptr == nullptr) {
+            return nullptr;
+        }
+
+        for (clang::ASTUnit::stored_diag_iterator it = (*err_unit)->stored_diag_begin(),
+                it_end = (*err_unit)->stored_diag_end();
+                it != it_end; ++it)
+        {
+            switch (it->getLevel()) {
+                case clang::DiagnosticsEngine::Ignored:
+                case clang::DiagnosticsEngine::Note:
+                case clang::DiagnosticsEngine::Remark:
+                case clang::DiagnosticsEngine::Warning:
+                    continue;
+                case clang::DiagnosticsEngine::Error:
+                case clang::DiagnosticsEngine::Fatal:
+                    break;
+            }
+            llvm::StringRef msg_str_ref = it->getMessage();
+            if (*errors_len >= cap) {
+                cap *= 2;
+                Stage2ErrorMsg *new_errors = reinterpret_cast<Stage2ErrorMsg *>(
+                        realloc(*errors_ptr, cap * sizeof(Stage2ErrorMsg)));
+                if (new_errors == nullptr) {
+                    free(*errors_ptr);
+                    *errors_ptr = nullptr;
+                    *errors_len = 0;
+                    return nullptr;
+                }
+                *errors_ptr = new_errors;
+            }
+            Stage2ErrorMsg *msg = *errors_ptr + *errors_len;
+            *errors_len += 1;
+            msg->msg_ptr = (const char *)msg_str_ref.bytes_begin();
+            msg->msg_len = msg_str_ref.size();
+
+            clang::FullSourceLoc fsl = it->getLocation();
+            if (fsl.hasManager()) {
+                clang::FileID file_id = fsl.getFileID();
+                clang::StringRef filename = fsl.getManager().getFilename(fsl);
+                if (filename.empty()) {
+                    msg->filename_ptr = nullptr;
+                } else {
+                    msg->filename_ptr = (const char *)filename.bytes_begin();
+                    msg->filename_len = filename.size();
+                }
+                msg->source = (const char *)fsl.getManager().getBufferData(file_id).bytes_begin();
+                msg->line = fsl.getSpellingLineNumber() - 1;
+                msg->column = fsl.getSpellingColumnNumber() - 1;
+                msg->offset = fsl.getManager().getFileOffset(fsl);
+            } else {
+                // The only known way this gets triggered right now is if you have a lot of errors
+                // clang emits "too many errors emitted, stopping now"
+                msg->filename_ptr = nullptr;
+                msg->source = nullptr;
+            }
+        }
+
+        if (*errors_len == 0) {
+            free(*errors_ptr);
+            *errors_ptr = nullptr;
+        }
+
+        return nullptr;
+    }
+
+    return reinterpret_cast<ZigClangASTUnit *>(ast_unit);
+}
+
+void ZigClangErrorMsg_delete(Stage2ErrorMsg *ptr, size_t len) {
+    free(ptr);
+}
+
+void ZigClangASTUnit_delete(struct ZigClangASTUnit *self) {
+    delete reinterpret_cast<clang::ASTUnit *>(self);
+}
+
+enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBuiltinType *self) {
+    auto casted = reinterpret_cast<const clang::BuiltinType *>(self);
+    return (ZigClangBuiltinTypeKind)casted->getKind();
+}
+
+bool ZigClangFunctionType_getNoReturnAttr(const struct ZigClangFunctionType *self) {
+    auto casted = reinterpret_cast<const clang::FunctionType *>(self);
+    return casted->getNoReturnAttr();
+}
+
+enum ZigClangCallingConv ZigClangFunctionType_getCallConv(const struct ZigClangFunctionType *self) {
+    auto casted = reinterpret_cast<const clang::FunctionType *>(self);
+    return (ZigClangCallingConv)casted->getCallConv();
+}
+
+struct ZigClangQualType ZigClangFunctionType_getReturnType(const struct ZigClangFunctionType *self) {
+    auto casted = reinterpret_cast<const clang::FunctionType *>(self);
+    return bitcast(casted->getReturnType());
+}
+
+bool ZigClangFunctionProtoType_isVariadic(const struct ZigClangFunctionProtoType *self) {
+    auto casted = reinterpret_cast<const clang::FunctionProtoType *>(self);
+    return casted->isVariadic();
+}
+
+unsigned ZigClangFunctionProtoType_getNumParams(const struct ZigClangFunctionProtoType *self) {
+    auto casted = reinterpret_cast<const clang::FunctionProtoType *>(self);
+    return casted->getNumParams();
+}
+
+struct ZigClangQualType ZigClangFunctionProtoType_getParamType(const struct ZigClangFunctionProtoType *self,
+        unsigned index)
+{
+    auto casted = reinterpret_cast<const clang::FunctionProtoType *>(self);
+    return bitcast(casted->getParamType(index));
+}
+
+ZigClangCompoundStmt_const_body_iterator ZigClangCompoundStmt_body_begin(const struct ZigClangCompoundStmt *self) {
+    auto casted = reinterpret_cast<const clang::CompoundStmt *>(self);
+    return bitcast(casted->body_begin());
+}
+
+ZigClangCompoundStmt_const_body_iterator ZigClangCompoundStmt_body_end(const struct ZigClangCompoundStmt *self) {
+    auto casted = reinterpret_cast<const clang::CompoundStmt *>(self);
+    return bitcast(casted->body_end());
+}
diff --git a/src/zig_clang.h b/src/zig_clang.h
index c7d749cbd9..fd74536b28 100644
--- a/src/zig_clang.h
+++ b/src/zig_clang.h
@@ -8,14 +8,13 @@
 #ifndef ZIG_ZIG_CLANG_H
 #define ZIG_ZIG_CLANG_H
 
-#ifdef __cplusplus
-#define ZIG_EXTERN_C extern "C"
-#else
-#define ZIG_EXTERN_C
-#endif
+#include "userland.h"
+#include <inttypes.h>
+#include <stdbool.h>
 
 // ATTENTION: If you modify this file, be sure to update the corresponding
-// extern function declarations in the self-hosted compiler.
+// extern function declarations in the self-hosted compiler file
+// src-self-hosted/clang.zig.
 
 struct ZigClangSourceLocation {
     unsigned ID;
@@ -25,7 +24,14 @@ struct ZigClangQualType {
     void *ptr;
 };
 
+struct ZigClangAPValueLValueBase {
+    void *Ptr;
+    unsigned CallIndex;
+    unsigned Version;
+};
+
 struct ZigClangAPValue;
+struct ZigClangAPSInt;
 struct ZigClangASTContext;
 struct ZigClangASTUnit;
 struct ZigClangArraySubscriptExpr;
@@ -82,10 +88,10 @@ struct ZigClangSkipFunctionBodiesScope;
 struct ZigClangSourceManager;
 struct ZigClangSourceRange;
 struct ZigClangStmt;
-struct ZigClangStorageClass;
 struct ZigClangStringLiteral;
 struct ZigClangStringRef;
 struct ZigClangSwitchStmt;
+struct ZigClangTagDecl;
 struct ZigClangType;
 struct ZigClangTypedefNameDecl;
 struct ZigClangTypedefType;
@@ -94,6 +100,9 @@ struct ZigClangUnaryOperator;
 struct ZigClangValueDecl;
 struct ZigClangVarDecl;
 struct ZigClangWhileStmt;
+struct ZigClangFunctionType;
+
+typedef struct ZigClangStmt *const * ZigClangCompoundStmt_const_body_iterator;
 
 enum ZigClangBO {
     ZigClangBO_PtrMemD,
@@ -148,112 +157,674 @@ enum ZigClangUO {
     ZigClangUO_Coawait,
 };
 
-//struct ZigClangCC_AAPCS;
-//struct ZigClangCC_AAPCS_VFP;
-//struct ZigClangCC_C;
-//struct ZigClangCC_IntelOclBicc;
-//struct ZigClangCC_OpenCLKernel;
-//struct ZigClangCC_PreserveAll;
-//struct ZigClangCC_PreserveMost;
-//struct ZigClangCC_SpirFunction;
-//struct ZigClangCC_Swift;
-//struct ZigClangCC_Win64;
-//struct ZigClangCC_X86FastCall;
-//struct ZigClangCC_X86Pascal;
-//struct ZigClangCC_X86RegCall;
-//struct ZigClangCC_X86StdCall;
-//struct ZigClangCC_X86ThisCall;
-//struct ZigClangCC_X86VectorCall;
-//struct ZigClangCC_X86_64SysV;
-
-//struct ZigClangCK_ARCConsumeObject;
-//struct ZigClangCK_ARCExtendBlockObject;
-//struct ZigClangCK_ARCProduceObject;
-//struct ZigClangCK_ARCReclaimReturnedObject;
-//struct ZigClangCK_AddressSpaceConversion;
-//struct ZigClangCK_AnyPointerToBlockPointerCast;
-//struct ZigClangCK_ArrayToPointerDecay;
-//struct ZigClangCK_AtomicToNonAtomic;
-//struct ZigClangCK_BaseToDerived;
-//struct ZigClangCK_BaseToDerivedMemberPointer;
-//struct ZigClangCK_BitCast;
-//struct ZigClangCK_BlockPointerToObjCPointerCast;
-//struct ZigClangCK_BooleanToSignedIntegral;
-//struct ZigClangCK_BuiltinFnToFnPtr;
-//struct ZigClangCK_CPointerToObjCPointerCast;
-//struct ZigClangCK_ConstructorConversion;
-//struct ZigClangCK_CopyAndAutoreleaseBlockObject;
-//struct ZigClangCK_Dependent;
-//struct ZigClangCK_DerivedToBase;
-//struct ZigClangCK_DerivedToBaseMemberPointer;
-//struct ZigClangCK_Dynamic;
-//struct ZigClangCK_FloatingCast;
-//struct ZigClangCK_FloatingComplexCast;
-//struct ZigClangCK_FloatingComplexToBoolean;
-//struct ZigClangCK_FloatingComplexToIntegralComplex;
-//struct ZigClangCK_FloatingComplexToReal;
-//struct ZigClangCK_FloatingRealToComplex;
-//struct ZigClangCK_FloatingToBoolean;
-//struct ZigClangCK_FloatingToIntegral;
-//struct ZigClangCK_FunctionToPointerDecay;
-//struct ZigClangCK_IntToOCLSampler;
-//struct ZigClangCK_IntegralCast;
-//struct ZigClangCK_IntegralComplexCast;
-//struct ZigClangCK_IntegralComplexToBoolean;
-//struct ZigClangCK_IntegralComplexToFloatingComplex;
-//struct ZigClangCK_IntegralComplexToReal;
-//struct ZigClangCK_IntegralRealToComplex;
-//struct ZigClangCK_IntegralToBoolean;
-//struct ZigClangCK_IntegralToFloating;
-//struct ZigClangCK_IntegralToPointer;
-//struct ZigClangCK_LValueBitCast;
-//struct ZigClangCK_LValueToRValue;
-//struct ZigClangCK_MemberPointerToBoolean;
-//struct ZigClangCK_NoOp;
-//struct ZigClangCK_NonAtomicToAtomic;
-//struct ZigClangCK_NullToMemberPointer;
-//struct ZigClangCK_NullToPointer;
-//struct ZigClangCK_ObjCObjectLValueCast;
-//struct ZigClangCK_PointerToBoolean;
-//struct ZigClangCK_PointerToIntegral;
-//struct ZigClangCK_ReinterpretMemberPointer;
-//struct ZigClangCK_ToUnion;
-//struct ZigClangCK_ToVoid;
-//struct ZigClangCK_UncheckedDerivedToBase;
-//struct ZigClangCK_UserDefinedConversion;
-//struct ZigClangCK_VectorSplat;
-//struct ZigClangCK_ZeroToOCLEvent;
-//struct ZigClangCK_ZeroToOCLQueue;
-
-//struct ZigClangETK_Class;
-//struct ZigClangETK_Enum;
-//struct ZigClangETK_Interface;
-//struct ZigClangETK_None;
-//struct ZigClangETK_Struct;
-//struct ZigClangETK_Typename;
-//struct ZigClangETK_Union;
-
-//struct ZigClangSC_None;
-//struct ZigClangSC_PrivateExtern;
-//struct ZigClangSC_Static;
-
-//struct ZigClangTU_Complete;
-
-ZIG_EXTERN_C ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const ZigClangSourceManager *,
-        ZigClangSourceLocation Loc);
-ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const ZigClangSourceManager *,
-        ZigClangSourceLocation SpellingLoc);
-ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingLineNumber(const ZigClangSourceManager *,
-        ZigClangSourceLocation Loc);
-ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingColumnNumber(const ZigClangSourceManager *,
-        ZigClangSourceLocation Loc);
-ZIG_EXTERN_C const char* ZigClangSourceManager_getCharacterData(const ZigClangSourceManager *,
-        ZigClangSourceLocation SL);
-
-ZIG_EXTERN_C ZigClangQualType ZigClangASTContext_getPointerType(const ZigClangASTContext*, ZigClangQualType T);
-
-ZIG_EXTERN_C ZigClangASTContext *ZigClangASTUnit_getASTContext(ZigClangASTUnit *);
-ZIG_EXTERN_C ZigClangSourceManager *ZigClangASTUnit_getSourceManager(ZigClangASTUnit *);
-ZIG_EXTERN_C bool ZigClangASTUnit_visitLocalTopLevelDecls(ZigClangASTUnit *, void *context, 
-    bool (*Fn)(void *context, const ZigClangDecl *decl));
+enum ZigClangTypeClass {
+    ZigClangType_Builtin,
+    ZigClangType_Complex,
+    ZigClangType_Pointer,
+    ZigClangType_BlockPointer,
+    ZigClangType_LValueReference,
+    ZigClangType_RValueReference,
+    ZigClangType_MemberPointer,
+    ZigClangType_ConstantArray,
+    ZigClangType_IncompleteArray,
+    ZigClangType_VariableArray,
+    ZigClangType_DependentSizedArray,
+    ZigClangType_DependentSizedExtVector,
+    ZigClangType_DependentAddressSpace,
+    ZigClangType_Vector,
+    ZigClangType_DependentVector,
+    ZigClangType_ExtVector,
+    ZigClangType_FunctionProto,
+    ZigClangType_FunctionNoProto,
+    ZigClangType_UnresolvedUsing,
+    ZigClangType_Paren,
+    ZigClangType_Typedef,
+    ZigClangType_Adjusted,
+    ZigClangType_Decayed,
+    ZigClangType_TypeOfExpr,
+    ZigClangType_TypeOf,
+    ZigClangType_Decltype,
+    ZigClangType_UnaryTransform,
+    ZigClangType_Record,
+    ZigClangType_Enum,
+    ZigClangType_Elaborated,
+    ZigClangType_Attributed,
+    ZigClangType_TemplateTypeParm,
+    ZigClangType_SubstTemplateTypeParm,
+    ZigClangType_SubstTemplateTypeParmPack,
+    ZigClangType_TemplateSpecialization,
+    ZigClangType_Auto,
+    ZigClangType_DeducedTemplateSpecialization,
+    ZigClangType_InjectedClassName,
+    ZigClangType_DependentName,
+    ZigClangType_DependentTemplateSpecialization,
+    ZigClangType_PackExpansion,
+    ZigClangType_ObjCTypeParam,
+    ZigClangType_ObjCObject,
+    ZigClangType_ObjCInterface,
+    ZigClangType_ObjCObjectPointer,
+    ZigClangType_Pipe,
+    ZigClangType_Atomic,
+};
+
+enum ZigClangStmtClass {
+    ZigClangStmt_NoStmtClass = 0,
+    ZigClangStmt_GCCAsmStmtClass,
+    ZigClangStmt_MSAsmStmtClass,
+    ZigClangStmt_AttributedStmtClass,
+    ZigClangStmt_BreakStmtClass,
+    ZigClangStmt_CXXCatchStmtClass,
+    ZigClangStmt_CXXForRangeStmtClass,
+    ZigClangStmt_CXXTryStmtClass,
+    ZigClangStmt_CapturedStmtClass,
+    ZigClangStmt_CompoundStmtClass,
+    ZigClangStmt_ContinueStmtClass,
+    ZigClangStmt_CoreturnStmtClass,
+    ZigClangStmt_CoroutineBodyStmtClass,
+    ZigClangStmt_DeclStmtClass,
+    ZigClangStmt_DoStmtClass,
+    ZigClangStmt_BinaryConditionalOperatorClass,
+    ZigClangStmt_ConditionalOperatorClass,
+    ZigClangStmt_AddrLabelExprClass,
+    ZigClangStmt_ArrayInitIndexExprClass,
+    ZigClangStmt_ArrayInitLoopExprClass,
+    ZigClangStmt_ArraySubscriptExprClass,
+    ZigClangStmt_ArrayTypeTraitExprClass,
+    ZigClangStmt_AsTypeExprClass,
+    ZigClangStmt_AtomicExprClass,
+    ZigClangStmt_BinaryOperatorClass,
+    ZigClangStmt_CompoundAssignOperatorClass,
+    ZigClangStmt_BlockExprClass,
+    ZigClangStmt_CXXBindTemporaryExprClass,
+    ZigClangStmt_CXXBoolLiteralExprClass,
+    ZigClangStmt_CXXConstructExprClass,
+    ZigClangStmt_CXXTemporaryObjectExprClass,
+    ZigClangStmt_CXXDefaultArgExprClass,
+    ZigClangStmt_CXXDefaultInitExprClass,
+    ZigClangStmt_CXXDeleteExprClass,
+    ZigClangStmt_CXXDependentScopeMemberExprClass,
+    ZigClangStmt_CXXFoldExprClass,
+    ZigClangStmt_CXXInheritedCtorInitExprClass,
+    ZigClangStmt_CXXNewExprClass,
+    ZigClangStmt_CXXNoexceptExprClass,
+    ZigClangStmt_CXXNullPtrLiteralExprClass,
+    ZigClangStmt_CXXPseudoDestructorExprClass,
+    ZigClangStmt_CXXScalarValueInitExprClass,
+    ZigClangStmt_CXXStdInitializerListExprClass,
+    ZigClangStmt_CXXThisExprClass,
+    ZigClangStmt_CXXThrowExprClass,
+    ZigClangStmt_CXXTypeidExprClass,
+    ZigClangStmt_CXXUnresolvedConstructExprClass,
+    ZigClangStmt_CXXUuidofExprClass,
+    ZigClangStmt_CallExprClass,
+    ZigClangStmt_CUDAKernelCallExprClass,
+    ZigClangStmt_CXXMemberCallExprClass,
+    ZigClangStmt_CXXOperatorCallExprClass,
+    ZigClangStmt_UserDefinedLiteralClass,
+    ZigClangStmt_CStyleCastExprClass,
+    ZigClangStmt_CXXFunctionalCastExprClass,
+    ZigClangStmt_CXXConstCastExprClass,
+    ZigClangStmt_CXXDynamicCastExprClass,
+    ZigClangStmt_CXXReinterpretCastExprClass,
+    ZigClangStmt_CXXStaticCastExprClass,
+    ZigClangStmt_ObjCBridgedCastExprClass,
+    ZigClangStmt_ImplicitCastExprClass,
+    ZigClangStmt_CharacterLiteralClass,
+    ZigClangStmt_ChooseExprClass,
+    ZigClangStmt_CompoundLiteralExprClass,
+    ZigClangStmt_ConvertVectorExprClass,
+    ZigClangStmt_CoawaitExprClass,
+    ZigClangStmt_CoyieldExprClass,
+    ZigClangStmt_DeclRefExprClass,
+    ZigClangStmt_DependentCoawaitExprClass,
+    ZigClangStmt_DependentScopeDeclRefExprClass,
+    ZigClangStmt_DesignatedInitExprClass,
+    ZigClangStmt_DesignatedInitUpdateExprClass,
+    ZigClangStmt_ExpressionTraitExprClass,
+    ZigClangStmt_ExtVectorElementExprClass,
+    ZigClangStmt_FixedPointLiteralClass,
+    ZigClangStmt_FloatingLiteralClass,
+    ZigClangStmt_ConstantExprClass,
+    ZigClangStmt_ExprWithCleanupsClass,
+    ZigClangStmt_FunctionParmPackExprClass,
+    ZigClangStmt_GNUNullExprClass,
+    ZigClangStmt_GenericSelectionExprClass,
+    ZigClangStmt_ImaginaryLiteralClass,
+    ZigClangStmt_ImplicitValueInitExprClass,
+    ZigClangStmt_InitListExprClass,
+    ZigClangStmt_IntegerLiteralClass,
+    ZigClangStmt_LambdaExprClass,
+    ZigClangStmt_MSPropertyRefExprClass,
+    ZigClangStmt_MSPropertySubscriptExprClass,
+    ZigClangStmt_MaterializeTemporaryExprClass,
+    ZigClangStmt_MemberExprClass,
+    ZigClangStmt_NoInitExprClass,
+    ZigClangStmt_OMPArraySectionExprClass,
+    ZigClangStmt_ObjCArrayLiteralClass,
+    ZigClangStmt_ObjCAvailabilityCheckExprClass,
+    ZigClangStmt_ObjCBoolLiteralExprClass,
+    ZigClangStmt_ObjCBoxedExprClass,
+    ZigClangStmt_ObjCDictionaryLiteralClass,
+    ZigClangStmt_ObjCEncodeExprClass,
+    ZigClangStmt_ObjCIndirectCopyRestoreExprClass,
+    ZigClangStmt_ObjCIsaExprClass,
+    ZigClangStmt_ObjCIvarRefExprClass,
+    ZigClangStmt_ObjCMessageExprClass,
+    ZigClangStmt_ObjCPropertyRefExprClass,
+    ZigClangStmt_ObjCProtocolExprClass,
+    ZigClangStmt_ObjCSelectorExprClass,
+    ZigClangStmt_ObjCStringLiteralClass,
+    ZigClangStmt_ObjCSubscriptRefExprClass,
+    ZigClangStmt_OffsetOfExprClass,
+    ZigClangStmt_OpaqueValueExprClass,
+    ZigClangStmt_UnresolvedLookupExprClass,
+    ZigClangStmt_UnresolvedMemberExprClass,
+    ZigClangStmt_PackExpansionExprClass,
+    ZigClangStmt_ParenExprClass,
+    ZigClangStmt_ParenListExprClass,
+    ZigClangStmt_PredefinedExprClass,
+    ZigClangStmt_PseudoObjectExprClass,
+    ZigClangStmt_ShuffleVectorExprClass,
+    ZigClangStmt_SizeOfPackExprClass,
+    ZigClangStmt_StmtExprClass,
+    ZigClangStmt_StringLiteralClass,
+    ZigClangStmt_SubstNonTypeTemplateParmExprClass,
+    ZigClangStmt_SubstNonTypeTemplateParmPackExprClass,
+    ZigClangStmt_TypeTraitExprClass,
+    ZigClangStmt_TypoExprClass,
+    ZigClangStmt_UnaryExprOrTypeTraitExprClass,
+    ZigClangStmt_UnaryOperatorClass,
+    ZigClangStmt_VAArgExprClass,
+    ZigClangStmt_ForStmtClass,
+    ZigClangStmt_GotoStmtClass,
+    ZigClangStmt_IfStmtClass,
+    ZigClangStmt_IndirectGotoStmtClass,
+    ZigClangStmt_LabelStmtClass,
+    ZigClangStmt_MSDependentExistsStmtClass,
+    ZigClangStmt_NullStmtClass,
+    ZigClangStmt_OMPAtomicDirectiveClass,
+    ZigClangStmt_OMPBarrierDirectiveClass,
+    ZigClangStmt_OMPCancelDirectiveClass,
+    ZigClangStmt_OMPCancellationPointDirectiveClass,
+    ZigClangStmt_OMPCriticalDirectiveClass,
+    ZigClangStmt_OMPFlushDirectiveClass,
+    ZigClangStmt_OMPDistributeDirectiveClass,
+    ZigClangStmt_OMPDistributeParallelForDirectiveClass,
+    ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass,
+    ZigClangStmt_OMPDistributeSimdDirectiveClass,
+    ZigClangStmt_OMPForDirectiveClass,
+    ZigClangStmt_OMPForSimdDirectiveClass,
+    ZigClangStmt_OMPParallelForDirectiveClass,
+    ZigClangStmt_OMPParallelForSimdDirectiveClass,
+    ZigClangStmt_OMPSimdDirectiveClass,
+    ZigClangStmt_OMPTargetParallelForSimdDirectiveClass,
+    ZigClangStmt_OMPTargetSimdDirectiveClass,
+    ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass,
+    ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass,
+    ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
+    ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass,
+    ZigClangStmt_OMPTaskLoopDirectiveClass,
+    ZigClangStmt_OMPTaskLoopSimdDirectiveClass,
+    ZigClangStmt_OMPTeamsDistributeDirectiveClass,
+    ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass,
+    ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass,
+    ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass,
+    ZigClangStmt_OMPMasterDirectiveClass,
+    ZigClangStmt_OMPOrderedDirectiveClass,
+    ZigClangStmt_OMPParallelDirectiveClass,
+    ZigClangStmt_OMPParallelSectionsDirectiveClass,
+    ZigClangStmt_OMPSectionDirectiveClass,
+    ZigClangStmt_OMPSectionsDirectiveClass,
+    ZigClangStmt_OMPSingleDirectiveClass,
+    ZigClangStmt_OMPTargetDataDirectiveClass,
+    ZigClangStmt_OMPTargetDirectiveClass,
+    ZigClangStmt_OMPTargetEnterDataDirectiveClass,
+    ZigClangStmt_OMPTargetExitDataDirectiveClass,
+    ZigClangStmt_OMPTargetParallelDirectiveClass,
+    ZigClangStmt_OMPTargetParallelForDirectiveClass,
+    ZigClangStmt_OMPTargetTeamsDirectiveClass,
+    ZigClangStmt_OMPTargetUpdateDirectiveClass,
+    ZigClangStmt_OMPTaskDirectiveClass,
+    ZigClangStmt_OMPTaskgroupDirectiveClass,
+    ZigClangStmt_OMPTaskwaitDirectiveClass,
+    ZigClangStmt_OMPTaskyieldDirectiveClass,
+    ZigClangStmt_OMPTeamsDirectiveClass,
+    ZigClangStmt_ObjCAtCatchStmtClass,
+    ZigClangStmt_ObjCAtFinallyStmtClass,
+    ZigClangStmt_ObjCAtSynchronizedStmtClass,
+    ZigClangStmt_ObjCAtThrowStmtClass,
+    ZigClangStmt_ObjCAtTryStmtClass,
+    ZigClangStmt_ObjCAutoreleasePoolStmtClass,
+    ZigClangStmt_ObjCForCollectionStmtClass,
+    ZigClangStmt_ReturnStmtClass,
+    ZigClangStmt_SEHExceptStmtClass,
+    ZigClangStmt_SEHFinallyStmtClass,
+    ZigClangStmt_SEHLeaveStmtClass,
+    ZigClangStmt_SEHTryStmtClass,
+    ZigClangStmt_CaseStmtClass,
+    ZigClangStmt_DefaultStmtClass,
+    ZigClangStmt_SwitchStmtClass,
+    ZigClangStmt_WhileStmtClass,
+};
+
+enum ZigClangCK {
+    ZigClangCK_Dependent,
+    ZigClangCK_BitCast,
+    ZigClangCK_LValueBitCast,
+    ZigClangCK_LValueToRValue,
+    ZigClangCK_NoOp,
+    ZigClangCK_BaseToDerived,
+    ZigClangCK_DerivedToBase,
+    ZigClangCK_UncheckedDerivedToBase,
+    ZigClangCK_Dynamic,
+    ZigClangCK_ToUnion,
+    ZigClangCK_ArrayToPointerDecay,
+    ZigClangCK_FunctionToPointerDecay,
+    ZigClangCK_NullToPointer,
+    ZigClangCK_NullToMemberPointer,
+    ZigClangCK_BaseToDerivedMemberPointer,
+    ZigClangCK_DerivedToBaseMemberPointer,
+    ZigClangCK_MemberPointerToBoolean,
+    ZigClangCK_ReinterpretMemberPointer,
+    ZigClangCK_UserDefinedConversion,
+    ZigClangCK_ConstructorConversion,
+    ZigClangCK_IntegralToPointer,
+    ZigClangCK_PointerToIntegral,
+    ZigClangCK_PointerToBoolean,
+    ZigClangCK_ToVoid,
+    ZigClangCK_VectorSplat,
+    ZigClangCK_IntegralCast,
+    ZigClangCK_IntegralToBoolean,
+    ZigClangCK_IntegralToFloating,
+    ZigClangCK_FixedPointCast,
+    ZigClangCK_FixedPointToBoolean,
+    ZigClangCK_FloatingToIntegral,
+    ZigClangCK_FloatingToBoolean,
+    ZigClangCK_BooleanToSignedIntegral,
+    ZigClangCK_FloatingCast,
+    ZigClangCK_CPointerToObjCPointerCast,
+    ZigClangCK_BlockPointerToObjCPointerCast,
+    ZigClangCK_AnyPointerToBlockPointerCast,
+    ZigClangCK_ObjCObjectLValueCast,
+    ZigClangCK_FloatingRealToComplex,
+    ZigClangCK_FloatingComplexToReal,
+    ZigClangCK_FloatingComplexToBoolean,
+    ZigClangCK_FloatingComplexCast,
+    ZigClangCK_FloatingComplexToIntegralComplex,
+    ZigClangCK_IntegralRealToComplex,
+    ZigClangCK_IntegralComplexToReal,
+    ZigClangCK_IntegralComplexToBoolean,
+    ZigClangCK_IntegralComplexCast,
+    ZigClangCK_IntegralComplexToFloatingComplex,
+    ZigClangCK_ARCProduceObject,
+    ZigClangCK_ARCConsumeObject,
+    ZigClangCK_ARCReclaimReturnedObject,
+    ZigClangCK_ARCExtendBlockObject,
+    ZigClangCK_AtomicToNonAtomic,
+    ZigClangCK_NonAtomicToAtomic,
+    ZigClangCK_CopyAndAutoreleaseBlockObject,
+    ZigClangCK_BuiltinFnToFnPtr,
+    ZigClangCK_ZeroToOCLOpaqueType,
+    ZigClangCK_AddressSpaceConversion,
+    ZigClangCK_IntToOCLSampler,
+};
+
+enum ZigClangAPValueKind {
+    ZigClangAPValueUninitialized,
+    ZigClangAPValueInt,
+    ZigClangAPValueFloat,
+    ZigClangAPValueComplexInt,
+    ZigClangAPValueComplexFloat,
+    ZigClangAPValueLValue,
+    ZigClangAPValueVector,
+    ZigClangAPValueArray,
+    ZigClangAPValueStruct,
+    ZigClangAPValueUnion,
+    ZigClangAPValueMemberPointer,
+    ZigClangAPValueAddrLabelDiff,
+};
+
+enum ZigClangDeclKind {
+    ZigClangDeclAccessSpec,
+    ZigClangDeclBlock,
+    ZigClangDeclCaptured,
+    ZigClangDeclClassScopeFunctionSpecialization,
+    ZigClangDeclEmpty,
+    ZigClangDeclExport,
+    ZigClangDeclExternCContext,
+    ZigClangDeclFileScopeAsm,
+    ZigClangDeclFriend,
+    ZigClangDeclFriendTemplate,
+    ZigClangDeclImport,
+    ZigClangDeclLinkageSpec,
+    ZigClangDeclLabel,
+    ZigClangDeclNamespace,
+    ZigClangDeclNamespaceAlias,
+    ZigClangDeclObjCCompatibleAlias,
+    ZigClangDeclObjCCategory,
+    ZigClangDeclObjCCategoryImpl,
+    ZigClangDeclObjCImplementation,
+    ZigClangDeclObjCInterface,
+    ZigClangDeclObjCProtocol,
+    ZigClangDeclObjCMethod,
+    ZigClangDeclObjCProperty,
+    ZigClangDeclBuiltinTemplate,
+    ZigClangDeclClassTemplate,
+    ZigClangDeclFunctionTemplate,
+    ZigClangDeclTypeAliasTemplate,
+    ZigClangDeclVarTemplate,
+    ZigClangDeclTemplateTemplateParm,
+    ZigClangDeclEnum,
+    ZigClangDeclRecord,
+    ZigClangDeclCXXRecord,
+    ZigClangDeclClassTemplateSpecialization,
+    ZigClangDeclClassTemplatePartialSpecialization,
+    ZigClangDeclTemplateTypeParm,
+    ZigClangDeclObjCTypeParam,
+    ZigClangDeclTypeAlias,
+    ZigClangDeclTypedef,
+    ZigClangDeclUnresolvedUsingTypename,
+    ZigClangDeclUsing,
+    ZigClangDeclUsingDirective,
+    ZigClangDeclUsingPack,
+    ZigClangDeclUsingShadow,
+    ZigClangDeclConstructorUsingShadow,
+    ZigClangDeclBinding,
+    ZigClangDeclField,
+    ZigClangDeclObjCAtDefsField,
+    ZigClangDeclObjCIvar,
+    ZigClangDeclFunction,
+    ZigClangDeclCXXDeductionGuide,
+    ZigClangDeclCXXMethod,
+    ZigClangDeclCXXConstructor,
+    ZigClangDeclCXXConversion,
+    ZigClangDeclCXXDestructor,
+    ZigClangDeclMSProperty,
+    ZigClangDeclNonTypeTemplateParm,
+    ZigClangDeclVar,
+    ZigClangDeclDecomposition,
+    ZigClangDeclImplicitParam,
+    ZigClangDeclOMPCapturedExpr,
+    ZigClangDeclParmVar,
+    ZigClangDeclVarTemplateSpecialization,
+    ZigClangDeclVarTemplatePartialSpecialization,
+    ZigClangDeclEnumConstant,
+    ZigClangDeclIndirectField,
+    ZigClangDeclOMPDeclareReduction,
+    ZigClangDeclUnresolvedUsingValue,
+    ZigClangDeclOMPRequires,
+    ZigClangDeclOMPThreadPrivate,
+    ZigClangDeclObjCPropertyImpl,
+    ZigClangDeclPragmaComment,
+    ZigClangDeclPragmaDetectMismatch,
+    ZigClangDeclStaticAssert,
+    ZigClangDeclTranslationUnit,
+};
+
+enum ZigClangBuiltinTypeKind {
+    ZigClangBuiltinTypeOCLImage1dRO,
+    ZigClangBuiltinTypeOCLImage1dArrayRO,
+    ZigClangBuiltinTypeOCLImage1dBufferRO,
+    ZigClangBuiltinTypeOCLImage2dRO,
+    ZigClangBuiltinTypeOCLImage2dArrayRO,
+    ZigClangBuiltinTypeOCLImage2dDepthRO,
+    ZigClangBuiltinTypeOCLImage2dArrayDepthRO,
+    ZigClangBuiltinTypeOCLImage2dMSAARO,
+    ZigClangBuiltinTypeOCLImage2dArrayMSAARO,
+    ZigClangBuiltinTypeOCLImage2dMSAADepthRO,
+    ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRO,
+    ZigClangBuiltinTypeOCLImage3dRO,
+    ZigClangBuiltinTypeOCLImage1dWO,
+    ZigClangBuiltinTypeOCLImage1dArrayWO,
+    ZigClangBuiltinTypeOCLImage1dBufferWO,
+    ZigClangBuiltinTypeOCLImage2dWO,
+    ZigClangBuiltinTypeOCLImage2dArrayWO,
+    ZigClangBuiltinTypeOCLImage2dDepthWO,
+    ZigClangBuiltinTypeOCLImage2dArrayDepthWO,
+    ZigClangBuiltinTypeOCLImage2dMSAAWO,
+    ZigClangBuiltinTypeOCLImage2dArrayMSAAWO,
+    ZigClangBuiltinTypeOCLImage2dMSAADepthWO,
+    ZigClangBuiltinTypeOCLImage2dArrayMSAADepthWO,
+    ZigClangBuiltinTypeOCLImage3dWO,
+    ZigClangBuiltinTypeOCLImage1dRW,
+    ZigClangBuiltinTypeOCLImage1dArrayRW,
+    ZigClangBuiltinTypeOCLImage1dBufferRW,
+    ZigClangBuiltinTypeOCLImage2dRW,
+    ZigClangBuiltinTypeOCLImage2dArrayRW,
+    ZigClangBuiltinTypeOCLImage2dDepthRW,
+    ZigClangBuiltinTypeOCLImage2dArrayDepthRW,
+    ZigClangBuiltinTypeOCLImage2dMSAARW,
+    ZigClangBuiltinTypeOCLImage2dArrayMSAARW,
+    ZigClangBuiltinTypeOCLImage2dMSAADepthRW,
+    ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRW,
+    ZigClangBuiltinTypeOCLImage3dRW,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCMcePayload,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCImePayload,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCRefPayload,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCSicPayload,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCMceResult,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResult,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCRefResult,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCSicResult,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultSingleRefStreamout,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultDualRefStreamout,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCImeSingleRefStreamin,
+    ZigClangBuiltinTypeOCLIntelSubgroupAVCImeDualRefStreamin,
+    ZigClangBuiltinTypeVoid,
+    ZigClangBuiltinTypeBool,
+    ZigClangBuiltinTypeChar_U,
+    ZigClangBuiltinTypeUChar,
+    ZigClangBuiltinTypeWChar_U,
+    ZigClangBuiltinTypeChar8,
+    ZigClangBuiltinTypeChar16,
+    ZigClangBuiltinTypeChar32,
+    ZigClangBuiltinTypeUShort,
+    ZigClangBuiltinTypeUInt,
+    ZigClangBuiltinTypeULong,
+    ZigClangBuiltinTypeULongLong,
+    ZigClangBuiltinTypeUInt128,
+    ZigClangBuiltinTypeChar_S,
+    ZigClangBuiltinTypeSChar,
+    ZigClangBuiltinTypeWChar_S,
+    ZigClangBuiltinTypeShort,
+    ZigClangBuiltinTypeInt,
+    ZigClangBuiltinTypeLong,
+    ZigClangBuiltinTypeLongLong,
+    ZigClangBuiltinTypeInt128,
+    ZigClangBuiltinTypeShortAccum,
+    ZigClangBuiltinTypeAccum,
+    ZigClangBuiltinTypeLongAccum,
+    ZigClangBuiltinTypeUShortAccum,
+    ZigClangBuiltinTypeUAccum,
+    ZigClangBuiltinTypeULongAccum,
+    ZigClangBuiltinTypeShortFract,
+    ZigClangBuiltinTypeFract,
+    ZigClangBuiltinTypeLongFract,
+    ZigClangBuiltinTypeUShortFract,
+    ZigClangBuiltinTypeUFract,
+    ZigClangBuiltinTypeULongFract,
+    ZigClangBuiltinTypeSatShortAccum,
+    ZigClangBuiltinTypeSatAccum,
+    ZigClangBuiltinTypeSatLongAccum,
+    ZigClangBuiltinTypeSatUShortAccum,
+    ZigClangBuiltinTypeSatUAccum,
+    ZigClangBuiltinTypeSatULongAccum,
+    ZigClangBuiltinTypeSatShortFract,
+    ZigClangBuiltinTypeSatFract,
+    ZigClangBuiltinTypeSatLongFract,
+    ZigClangBuiltinTypeSatUShortFract,
+    ZigClangBuiltinTypeSatUFract,
+    ZigClangBuiltinTypeSatULongFract,
+    ZigClangBuiltinTypeHalf,
+    ZigClangBuiltinTypeFloat,
+    ZigClangBuiltinTypeDouble,
+    ZigClangBuiltinTypeLongDouble,
+    ZigClangBuiltinTypeFloat16,
+    ZigClangBuiltinTypeFloat128,
+    ZigClangBuiltinTypeNullPtr,
+    ZigClangBuiltinTypeObjCId,
+    ZigClangBuiltinTypeObjCClass,
+    ZigClangBuiltinTypeObjCSel,
+    ZigClangBuiltinTypeOCLSampler,
+    ZigClangBuiltinTypeOCLEvent,
+    ZigClangBuiltinTypeOCLClkEvent,
+    ZigClangBuiltinTypeOCLQueue,
+    ZigClangBuiltinTypeOCLReserveID,
+    ZigClangBuiltinTypeDependent,
+    ZigClangBuiltinTypeOverload,
+    ZigClangBuiltinTypeBoundMember,
+    ZigClangBuiltinTypePseudoObject,
+    ZigClangBuiltinTypeUnknownAny,
+    ZigClangBuiltinTypeBuiltinFn,
+    ZigClangBuiltinTypeARCUnbridgedCast,
+    ZigClangBuiltinTypeOMPArraySection,
+};
+
+enum ZigClangCallingConv {
+    ZigClangCallingConv_C,           // __attribute__((cdecl))
+    ZigClangCallingConv_X86StdCall,  // __attribute__((stdcall))
+    ZigClangCallingConv_X86FastCall, // __attribute__((fastcall))
+    ZigClangCallingConv_X86ThisCall, // __attribute__((thiscall))
+    ZigClangCallingConv_X86VectorCall, // __attribute__((vectorcall))
+    ZigClangCallingConv_X86Pascal,   // __attribute__((pascal))
+    ZigClangCallingConv_Win64,       // __attribute__((ms_abi))
+    ZigClangCallingConv_X86_64SysV,  // __attribute__((sysv_abi))
+    ZigClangCallingConv_X86RegCall, // __attribute__((regcall))
+    ZigClangCallingConv_AAPCS,       // __attribute__((pcs("aapcs")))
+    ZigClangCallingConv_AAPCS_VFP,   // __attribute__((pcs("aapcs-vfp")))
+    ZigClangCallingConv_IntelOclBicc, // __attribute__((intel_ocl_bicc))
+    ZigClangCallingConv_SpirFunction, // default for OpenCL functions on SPIR target
+    ZigClangCallingConv_OpenCLKernel, // inferred for OpenCL kernels
+    ZigClangCallingConv_Swift,        // __attribute__((swiftcall))
+    ZigClangCallingConv_PreserveMost, // __attribute__((preserve_most))
+    ZigClangCallingConv_PreserveAll,  // __attribute__((preserve_all))
+    ZigClangCallingConv_AArch64VectorCall, // __attribute__((aarch64_vector_pcs))
+};
+
+enum ZigClangStorageClass {
+    // These are legal on both functions and variables.
+    ZigClangStorageClass_None,
+    ZigClangStorageClass_Extern,
+    ZigClangStorageClass_Static,
+    ZigClangStorageClass_PrivateExtern,
+
+    // These are only legal on variables.
+    ZigClangStorageClass_Auto,
+    ZigClangStorageClass_Register,
+};
+
+ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const struct ZigClangSourceManager *,
+        struct ZigClangSourceLocation Loc);
+ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const struct ZigClangSourceManager *,
+        struct ZigClangSourceLocation SpellingLoc);
+ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingLineNumber(const struct ZigClangSourceManager *,
+        struct ZigClangSourceLocation Loc);
+ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingColumnNumber(const struct ZigClangSourceManager *,
+        struct ZigClangSourceLocation Loc);
+ZIG_EXTERN_C const char* ZigClangSourceManager_getCharacterData(const struct ZigClangSourceManager *,
+        struct ZigClangSourceLocation SL);
+
+ZIG_EXTERN_C struct ZigClangQualType ZigClangASTContext_getPointerType(const struct ZigClangASTContext*, struct ZigClangQualType T);
+
+
+// Can return null.
+ZIG_EXTERN_C struct ZigClangASTUnit *ZigClangLoadFromCommandLine(const char **args_begin, const char **args_end,
+        struct Stage2ErrorMsg **errors_ptr, size_t *errors_len, const char *resources_path);
+ZIG_EXTERN_C void ZigClangASTUnit_delete(struct ZigClangASTUnit *);
+ZIG_EXTERN_C void ZigClangErrorMsg_delete(struct Stage2ErrorMsg *ptr, size_t len);
+
+ZIG_EXTERN_C struct ZigClangASTContext *ZigClangASTUnit_getASTContext(struct ZigClangASTUnit *);
+ZIG_EXTERN_C struct ZigClangSourceManager *ZigClangASTUnit_getSourceManager(struct ZigClangASTUnit *);
+ZIG_EXTERN_C bool ZigClangASTUnit_visitLocalTopLevelDecls(struct ZigClangASTUnit *, void *context, 
+    bool (*Fn)(void *context, const struct ZigClangDecl *decl));
+
+ZIG_EXTERN_C const struct ZigClangRecordDecl *ZigClangRecordType_getDecl(const struct ZigClangRecordType *record_ty);
+ZIG_EXTERN_C const struct ZigClangEnumDecl *ZigClangEnumType_getDecl(const struct ZigClangEnumType *record_ty);
+
+ZIG_EXTERN_C const struct ZigClangTagDecl *ZigClangRecordDecl_getCanonicalDecl(const struct ZigClangRecordDecl *record_decl);
+ZIG_EXTERN_C const struct ZigClangTagDecl *ZigClangEnumDecl_getCanonicalDecl(const struct ZigClangEnumDecl *);
+ZIG_EXTERN_C const struct ZigClangTypedefNameDecl *ZigClangTypedefNameDecl_getCanonicalDecl(const struct ZigClangTypedefNameDecl *);
+
+ZIG_EXTERN_C const struct ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const struct ZigClangRecordDecl *);
+ZIG_EXTERN_C const struct ZigClangEnumDecl *ZigClangEnumDecl_getDefinition(const struct ZigClangEnumDecl *);
+
+ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangRecordDecl_getLocation(const struct ZigClangRecordDecl *);
+ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangEnumDecl_getLocation(const struct ZigClangEnumDecl *);
+ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const struct ZigClangTypedefNameDecl *);
+ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangDecl_getLocation(const struct ZigClangDecl *);
+
+ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionDecl_getType(const struct ZigClangFunctionDecl *);
+ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangFunctionDecl_getLocation(const struct ZigClangFunctionDecl *);
+ZIG_EXTERN_C bool ZigClangFunctionDecl_hasBody(const struct ZigClangFunctionDecl *);
+ZIG_EXTERN_C enum ZigClangStorageClass ZigClangFunctionDecl_getStorageClass(const struct ZigClangFunctionDecl *);
+ZIG_EXTERN_C const struct ZigClangParmVarDecl *ZigClangFunctionDecl_getParamDecl(const struct ZigClangFunctionDecl *, unsigned i);
+ZIG_EXTERN_C const struct ZigClangStmt *ZigClangFunctionDecl_getBody(const struct ZigClangFunctionDecl *);
+
+ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const struct ZigClangRecordDecl *record_decl);
+ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const struct ZigClangRecordDecl *record_decl);
+ZIG_EXTERN_C bool ZigClangRecordDecl_isAnonymousStructOrUnion(const struct ZigClangRecordDecl *record_decl);
+
+ZIG_EXTERN_C struct ZigClangQualType ZigClangEnumDecl_getIntegerType(const struct ZigClangEnumDecl *);
+
+ZIG_EXTERN_C const char *ZigClangDecl_getName_bytes_begin(const struct ZigClangDecl *decl);
+ZIG_EXTERN_C enum ZigClangDeclKind ZigClangDecl_getKind(const struct ZigClangDecl *decl);
+ZIG_EXTERN_C const char *ZigClangDecl_getDeclKindName(const struct ZigClangDecl *decl);
+
+ZIG_EXTERN_C bool ZigClangSourceLocation_eq(struct ZigClangSourceLocation a, struct ZigClangSourceLocation b);
+
+ZIG_EXTERN_C const struct ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const struct ZigClangTypedefType *);
+ZIG_EXTERN_C struct ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const struct ZigClangTypedefNameDecl *);
+
+ZIG_EXTERN_C struct ZigClangQualType ZigClangQualType_getCanonicalType(struct ZigClangQualType);
+ZIG_EXTERN_C const struct ZigClangType *ZigClangQualType_getTypePtr(struct ZigClangQualType);
+ZIG_EXTERN_C void ZigClangQualType_addConst(struct ZigClangQualType *);
+ZIG_EXTERN_C bool ZigClangQualType_eq(struct ZigClangQualType, struct ZigClangQualType);
+ZIG_EXTERN_C bool ZigClangQualType_isConstQualified(struct ZigClangQualType);
+ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(struct ZigClangQualType);
+ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(struct ZigClangQualType);
+
+ZIG_EXTERN_C enum ZigClangTypeClass ZigClangType_getTypeClass(const struct ZigClangType *self);
+ZIG_EXTERN_C struct ZigClangQualType ZigClangType_getPointeeType(const struct ZigClangType *self);
+ZIG_EXTERN_C bool ZigClangType_isVoidType(const struct ZigClangType *self);
+ZIG_EXTERN_C const char *ZigClangType_getTypeClassName(const struct ZigClangType *self);
+
+ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangStmt_getBeginLoc(const struct ZigClangStmt *self);
+ZIG_EXTERN_C enum ZigClangStmtClass ZigClangStmt_getStmtClass(const struct ZigClangStmt *self);
+ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const struct ZigClangStmt *self);
+
+ZIG_EXTERN_C enum ZigClangStmtClass ZigClangExpr_getStmtClass(const struct ZigClangExpr *self);
+ZIG_EXTERN_C struct ZigClangQualType ZigClangExpr_getType(const struct ZigClangExpr *self);
+ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangExpr_getBeginLoc(const struct ZigClangExpr *self);
+
+ZIG_EXTERN_C enum ZigClangAPValueKind ZigClangAPValue_getKind(const struct ZigClangAPValue *self);
+ZIG_EXTERN_C const struct ZigClangAPSInt *ZigClangAPValue_getInt(const struct ZigClangAPValue *self);
+ZIG_EXTERN_C unsigned ZigClangAPValue_getArrayInitializedElts(const struct ZigClangAPValue *self);
+ZIG_EXTERN_C const struct ZigClangAPValue *ZigClangAPValue_getArrayInitializedElt(const struct ZigClangAPValue *self, unsigned i);
+ZIG_EXTERN_C const struct ZigClangAPValue *ZigClangAPValue_getArrayFiller(const struct ZigClangAPValue *self);
+ZIG_EXTERN_C unsigned ZigClangAPValue_getArraySize(const struct ZigClangAPValue *self);
+ZIG_EXTERN_C struct ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const struct ZigClangAPValue *self);
+
+ZIG_EXTERN_C bool ZigClangAPSInt_isSigned(const struct ZigClangAPSInt *self);
+ZIG_EXTERN_C bool ZigClangAPSInt_isNegative(const struct ZigClangAPSInt *self);
+ZIG_EXTERN_C const struct ZigClangAPSInt *ZigClangAPSInt_negate(const struct ZigClangAPSInt *self);
+ZIG_EXTERN_C void ZigClangAPSInt_free(const struct ZigClangAPSInt *self);
+ZIG_EXTERN_C const uint64_t *ZigClangAPSInt_getRawData(const struct ZigClangAPSInt *self);
+ZIG_EXTERN_C unsigned ZigClangAPSInt_getNumWords(const struct ZigClangAPSInt *self);
+
+ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(struct ZigClangAPValueLValueBase self);
+
+ZIG_EXTERN_C enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBuiltinType *self);
+
+ZIG_EXTERN_C bool ZigClangFunctionType_getNoReturnAttr(const struct ZigClangFunctionType *self);
+ZIG_EXTERN_C enum ZigClangCallingConv ZigClangFunctionType_getCallConv(const struct ZigClangFunctionType *self);
+ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionType_getReturnType(const struct ZigClangFunctionType *self);
+
+ZIG_EXTERN_C bool ZigClangFunctionProtoType_isVariadic(const struct ZigClangFunctionProtoType *self);
+ZIG_EXTERN_C unsigned ZigClangFunctionProtoType_getNumParams(const struct ZigClangFunctionProtoType *self);
+ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionProtoType_getParamType(const struct ZigClangFunctionProtoType *self, unsigned i);
+
+
+ZIG_EXTERN_C ZigClangCompoundStmt_const_body_iterator ZigClangCompoundStmt_body_begin(const struct ZigClangCompoundStmt *self);
+ZIG_EXTERN_C ZigClangCompoundStmt_const_body_iterator ZigClangCompoundStmt_body_end(const struct ZigClangCompoundStmt *self);
+
 #endif