Commit `eea2de108d`

Andrew Kelley <andrew@ziglang.org>

2019-05-09 22:52:30

translate-c: progress on self-hosted function prototypes

See #1964

master

1 parent 2146255

Changed files (5)

src

src-self-hosted

@@ -1061,72 +1061,72 @@ static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLoc
         case ZigClangType_FunctionProto:
         case ZigClangType_FunctionNoProto:
             {
-                const clang::FunctionType *fn_ty = reinterpret_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, bitcast(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;

@@ -1193,6 +1193,49 @@ static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBuiltinFn == clang::B
 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, "");
+
 
 static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), "");
 static ZigClangSourceLocation bitcast(clang::SourceLocation src) {
@@ -1693,3 +1736,18 @@ enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBu
     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());
+}

@@ -101,6 +101,7 @@ struct ZigClangUnaryOperator;
 struct ZigClangValueDecl;
 struct ZigClangVarDecl;
 struct ZigClangWhileStmt;
+struct ZigClangFunctionType;
 
 enum ZigClangBO {
     ZigClangBO_PtrMemD,
@@ -678,6 +679,27 @@ enum ZigClangBuiltinTypeKind {
     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))
+};
+
 ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const struct ZigClangSourceManager *,
         struct ZigClangSourceLocation Loc);
 ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const struct ZigClangSourceManager *,
@@ -776,4 +798,8 @@ ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(
 
 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);
+
 #endif

@@ -69,742 +69,388 @@ pub const struct_ZigClangUnaryOperator = @OpaqueType();
 pub const struct_ZigClangValueDecl = @OpaqueType();
 pub const struct_ZigClangVarDecl = @OpaqueType();
 pub const struct_ZigClangWhileStmt = @OpaqueType();
-pub const ZigClangBO_PtrMemD = enum_ZigClangBO._PtrMemD;
-pub const ZigClangBO_PtrMemI = enum_ZigClangBO._PtrMemI;
-pub const ZigClangBO_Mul = enum_ZigClangBO._Mul;
-pub const ZigClangBO_Div = enum_ZigClangBO._Div;
-pub const ZigClangBO_Rem = enum_ZigClangBO._Rem;
-pub const ZigClangBO_Add = enum_ZigClangBO._Add;
-pub const ZigClangBO_Sub = enum_ZigClangBO._Sub;
-pub const ZigClangBO_Shl = enum_ZigClangBO._Shl;
-pub const ZigClangBO_Shr = enum_ZigClangBO._Shr;
-pub const ZigClangBO_Cmp = enum_ZigClangBO._Cmp;
-pub const ZigClangBO_LT = enum_ZigClangBO._LT;
-pub const ZigClangBO_GT = enum_ZigClangBO._GT;
-pub const ZigClangBO_LE = enum_ZigClangBO._LE;
-pub const ZigClangBO_GE = enum_ZigClangBO._GE;
-pub const ZigClangBO_EQ = enum_ZigClangBO._EQ;
-pub const ZigClangBO_NE = enum_ZigClangBO._NE;
-pub const ZigClangBO_And = enum_ZigClangBO._And;
-pub const ZigClangBO_Xor = enum_ZigClangBO._Xor;
-pub const ZigClangBO_Or = enum_ZigClangBO._Or;
-pub const ZigClangBO_LAnd = enum_ZigClangBO._LAnd;
-pub const ZigClangBO_LOr = enum_ZigClangBO._LOr;
-pub const ZigClangBO_Assign = enum_ZigClangBO._Assign;
-pub const ZigClangBO_MulAssign = enum_ZigClangBO._MulAssign;
-pub const ZigClangBO_DivAssign = enum_ZigClangBO._DivAssign;
-pub const ZigClangBO_RemAssign = enum_ZigClangBO._RemAssign;
-pub const ZigClangBO_AddAssign = enum_ZigClangBO._AddAssign;
-pub const ZigClangBO_SubAssign = enum_ZigClangBO._SubAssign;
-pub const ZigClangBO_ShlAssign = enum_ZigClangBO._ShlAssign;
-pub const ZigClangBO_ShrAssign = enum_ZigClangBO._ShrAssign;
-pub const ZigClangBO_AndAssign = enum_ZigClangBO._AndAssign;
-pub const ZigClangBO_XorAssign = enum_ZigClangBO._XorAssign;
-pub const ZigClangBO_OrAssign = enum_ZigClangBO._OrAssign;
-pub const ZigClangBO_Comma = enum_ZigClangBO._Comma;
-pub const enum_ZigClangBO = extern enum {
-    _PtrMemD,
-    _PtrMemI,
-    _Mul,
-    _Div,
-    _Rem,
-    _Add,
-    _Sub,
-    _Shl,
-    _Shr,
-    _Cmp,
-    _LT,
-    _GT,
-    _LE,
-    _GE,
-    _EQ,
-    _NE,
-    _And,
-    _Xor,
-    _Or,
-    _LAnd,
-    _LOr,
-    _Assign,
-    _MulAssign,
-    _DivAssign,
-    _RemAssign,
-    _AddAssign,
-    _SubAssign,
-    _ShlAssign,
-    _ShrAssign,
-    _AndAssign,
-    _XorAssign,
-    _OrAssign,
-    _Comma,
+pub const ZigClangFunctionType = @OpaqueType();
+
+pub const ZigClangBO = extern enum {
+    PtrMemD,
+    PtrMemI,
+    Mul,
+    Div,
+    Rem,
+    Add,
+    Sub,
+    Shl,
+    Shr,
+    Cmp,
+    LT,
+    GT,
+    LE,
+    GE,
+    EQ,
+    NE,
+    And,
+    Xor,
+    Or,
+    LAnd,
+    LOr,
+    Assign,
+    MulAssign,
+    DivAssign,
+    RemAssign,
+    AddAssign,
+    SubAssign,
+    ShlAssign,
+    ShrAssign,
+    AndAssign,
+    XorAssign,
+    OrAssign,
+    Comma,
 };
-pub const ZigClangUO_PostInc = enum_ZigClangUO._PostInc;
-pub const ZigClangUO_PostDec = enum_ZigClangUO._PostDec;
-pub const ZigClangUO_PreInc = enum_ZigClangUO._PreInc;
-pub const ZigClangUO_PreDec = enum_ZigClangUO._PreDec;
-pub const ZigClangUO_AddrOf = enum_ZigClangUO._AddrOf;
-pub const ZigClangUO_Deref = enum_ZigClangUO._Deref;
-pub const ZigClangUO_Plus = enum_ZigClangUO._Plus;
-pub const ZigClangUO_Minus = enum_ZigClangUO._Minus;
-pub const ZigClangUO_Not = enum_ZigClangUO._Not;
-pub const ZigClangUO_LNot = enum_ZigClangUO._LNot;
-pub const ZigClangUO_Real = enum_ZigClangUO._Real;
-pub const ZigClangUO_Imag = enum_ZigClangUO._Imag;
-pub const ZigClangUO_Extension = enum_ZigClangUO._Extension;
-pub const ZigClangUO_Coawait = enum_ZigClangUO._Coawait;
-pub const enum_ZigClangUO = extern enum {
-    _PostInc,
-    _PostDec,
-    _PreInc,
-    _PreDec,
-    _AddrOf,
-    _Deref,
-    _Plus,
-    _Minus,
-    _Not,
-    _LNot,
-    _Real,
-    _Imag,
-    _Extension,
-    _Coawait,
+
+pub const ZigClangUO = extern enum {
+    PostInc,
+    PostDec,
+    PreInc,
+    PreDec,
+    AddrOf,
+    Deref,
+    Plus,
+    Minus,
+    Not,
+    LNot,
+    Real,
+    Imag,
+    Extension,
+    Coawait,
 };
-pub const ZigClangType_Builtin = enum_ZigClangTypeClass.ZigClangType_Builtin;
-pub const ZigClangType_Complex = enum_ZigClangTypeClass.ZigClangType_Complex;
-pub const ZigClangType_Pointer = enum_ZigClangTypeClass.ZigClangType_Pointer;
-pub const ZigClangType_BlockPointer = enum_ZigClangTypeClass.ZigClangType_BlockPointer;
-pub const ZigClangType_LValueReference = enum_ZigClangTypeClass.ZigClangType_LValueReference;
-pub const ZigClangType_RValueReference = enum_ZigClangTypeClass.ZigClangType_RValueReference;
-pub const ZigClangType_MemberPointer = enum_ZigClangTypeClass.ZigClangType_MemberPointer;
-pub const ZigClangType_ConstantArray = enum_ZigClangTypeClass.ZigClangType_ConstantArray;
-pub const ZigClangType_IncompleteArray = enum_ZigClangTypeClass.ZigClangType_IncompleteArray;
-pub const ZigClangType_VariableArray = enum_ZigClangTypeClass.ZigClangType_VariableArray;
-pub const ZigClangType_DependentSizedArray = enum_ZigClangTypeClass.ZigClangType_DependentSizedArray;
-pub const ZigClangType_DependentSizedExtVector = enum_ZigClangTypeClass.ZigClangType_DependentSizedExtVector;
-pub const ZigClangType_DependentAddressSpace = enum_ZigClangTypeClass.ZigClangType_DependentAddressSpace;
-pub const ZigClangType_Vector = enum_ZigClangTypeClass.ZigClangType_Vector;
-pub const ZigClangType_DependentVector = enum_ZigClangTypeClass.ZigClangType_DependentVector;
-pub const ZigClangType_ExtVector = enum_ZigClangTypeClass.ZigClangType_ExtVector;
-pub const ZigClangType_FunctionProto = enum_ZigClangTypeClass.ZigClangType_FunctionProto;
-pub const ZigClangType_FunctionNoProto = enum_ZigClangTypeClass.ZigClangType_FunctionNoProto;
-pub const ZigClangType_UnresolvedUsing = enum_ZigClangTypeClass.ZigClangType_UnresolvedUsing;
-pub const ZigClangType_Paren = enum_ZigClangTypeClass.ZigClangType_Paren;
-pub const ZigClangType_Typedef = enum_ZigClangTypeClass.ZigClangType_Typedef;
-pub const ZigClangType_Adjusted = enum_ZigClangTypeClass.ZigClangType_Adjusted;
-pub const ZigClangType_Decayed = enum_ZigClangTypeClass.ZigClangType_Decayed;
-pub const ZigClangType_TypeOfExpr = enum_ZigClangTypeClass.ZigClangType_TypeOfExpr;
-pub const ZigClangType_TypeOf = enum_ZigClangTypeClass.ZigClangType_TypeOf;
-pub const ZigClangType_Decltype = enum_ZigClangTypeClass.ZigClangType_Decltype;
-pub const ZigClangType_UnaryTransform = enum_ZigClangTypeClass.ZigClangType_UnaryTransform;
-pub const ZigClangType_Record = enum_ZigClangTypeClass.ZigClangType_Record;
-pub const ZigClangType_Enum = enum_ZigClangTypeClass.ZigClangType_Enum;
-pub const ZigClangType_Elaborated = enum_ZigClangTypeClass.ZigClangType_Elaborated;
-pub const ZigClangType_Attributed = enum_ZigClangTypeClass.ZigClangType_Attributed;
-pub const ZigClangType_TemplateTypeParm = enum_ZigClangTypeClass.ZigClangType_TemplateTypeParm;
-pub const ZigClangType_SubstTemplateTypeParm = enum_ZigClangTypeClass.ZigClangType_SubstTemplateTypeParm;
-pub const ZigClangType_SubstTemplateTypeParmPack = enum_ZigClangTypeClass.ZigClangType_SubstTemplateTypeParmPack;
-pub const ZigClangType_TemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_TemplateSpecialization;
-pub const ZigClangType_Auto = enum_ZigClangTypeClass.ZigClangType_Auto;
-pub const ZigClangType_DeducedTemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_DeducedTemplateSpecialization;
-pub const ZigClangType_InjectedClassName = enum_ZigClangTypeClass.ZigClangType_InjectedClassName;
-pub const ZigClangType_DependentName = enum_ZigClangTypeClass.ZigClangType_DependentName;
-pub const ZigClangType_DependentTemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_DependentTemplateSpecialization;
-pub const ZigClangType_PackExpansion = enum_ZigClangTypeClass.ZigClangType_PackExpansion;
-pub const ZigClangType_ObjCTypeParam = enum_ZigClangTypeClass.ZigClangType_ObjCTypeParam;
-pub const ZigClangType_ObjCObject = enum_ZigClangTypeClass.ZigClangType_ObjCObject;
-pub const ZigClangType_ObjCInterface = enum_ZigClangTypeClass.ZigClangType_ObjCInterface;
-pub const ZigClangType_ObjCObjectPointer = enum_ZigClangTypeClass.ZigClangType_ObjCObjectPointer;
-pub const ZigClangType_Pipe = enum_ZigClangTypeClass.ZigClangType_Pipe;
-pub const ZigClangType_Atomic = enum_ZigClangTypeClass.ZigClangType_Atomic;
-pub const enum_ZigClangTypeClass = extern enum {
-    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,
+
+pub const ZigClangTypeClass = extern enum {
+    Builtin,
+    Complex,
+    Pointer,
+    BlockPointer,
+    LValueReference,
+    RValueReference,
+    MemberPointer,
+    ConstantArray,
+    IncompleteArray,
+    VariableArray,
+    DependentSizedArray,
+    DependentSizedExtVector,
+    DependentAddressSpace,
+    Vector,
+    DependentVector,
+    ExtVector,
+    FunctionProto,
+    FunctionNoProto,
+    UnresolvedUsing,
+    Paren,
+    Typedef,
+    Adjusted,
+    Decayed,
+    TypeOfExpr,
+    TypeOf,
+    Decltype,
+    UnaryTransform,
+    Record,
+    Enum,
+    Elaborated,
+    Attributed,
+    TemplateTypeParm,
+    SubstTemplateTypeParm,
+    SubstTemplateTypeParmPack,
+    TemplateSpecialization,
+    Auto,
+    DeducedTemplateSpecialization,
+    InjectedClassName,
+    DependentName,
+    DependentTemplateSpecialization,
+    PackExpansion,
+    ObjCTypeParam,
+    ObjCObject,
+    ObjCInterface,
+    ObjCObjectPointer,
+    Pipe,
+    Atomic,
 };
-pub const ZigClangStmt_NoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_NoStmtClass;
-pub const ZigClangStmt_GCCAsmStmtClass = enum_ZigClangStmtClass.ZigClangStmt_GCCAsmStmtClass;
-pub const ZigClangStmt_MSAsmStmtClass = enum_ZigClangStmtClass.ZigClangStmt_MSAsmStmtClass;
-pub const ZigClangStmt_AttributedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_AttributedStmtClass;
-pub const ZigClangStmt_BreakStmtClass = enum_ZigClangStmtClass.ZigClangStmt_BreakStmtClass;
-pub const ZigClangStmt_CXXCatchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXCatchStmtClass;
-pub const ZigClangStmt_CXXForRangeStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXForRangeStmtClass;
-pub const ZigClangStmt_CXXTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTryStmtClass;
-pub const ZigClangStmt_CapturedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CapturedStmtClass;
-pub const ZigClangStmt_CompoundStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundStmtClass;
-pub const ZigClangStmt_ContinueStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ContinueStmtClass;
-pub const ZigClangStmt_CoreturnStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CoreturnStmtClass;
-pub const ZigClangStmt_CoroutineBodyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CoroutineBodyStmtClass;
-pub const ZigClangStmt_DeclStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DeclStmtClass;
-pub const ZigClangStmt_DoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DoStmtClass;
-pub const ZigClangStmt_BinaryConditionalOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_BinaryConditionalOperatorClass;
-pub const ZigClangStmt_ConditionalOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_ConditionalOperatorClass;
-pub const ZigClangStmt_AddrLabelExprClass = enum_ZigClangStmtClass.ZigClangStmt_AddrLabelExprClass;
-pub const ZigClangStmt_ArrayInitIndexExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayInitIndexExprClass;
-pub const ZigClangStmt_ArrayInitLoopExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayInitLoopExprClass;
-pub const ZigClangStmt_ArraySubscriptExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArraySubscriptExprClass;
-pub const ZigClangStmt_ArrayTypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayTypeTraitExprClass;
-pub const ZigClangStmt_AsTypeExprClass = enum_ZigClangStmtClass.ZigClangStmt_AsTypeExprClass;
-pub const ZigClangStmt_AtomicExprClass = enum_ZigClangStmtClass.ZigClangStmt_AtomicExprClass;
-pub const ZigClangStmt_BinaryOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_BinaryOperatorClass;
-pub const ZigClangStmt_CompoundAssignOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundAssignOperatorClass;
-pub const ZigClangStmt_BlockExprClass = enum_ZigClangStmtClass.ZigClangStmt_BlockExprClass;
-pub const ZigClangStmt_CXXBindTemporaryExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXBindTemporaryExprClass;
-pub const ZigClangStmt_CXXBoolLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXBoolLiteralExprClass;
-pub const ZigClangStmt_CXXConstructExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXConstructExprClass;
-pub const ZigClangStmt_CXXTemporaryObjectExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTemporaryObjectExprClass;
-pub const ZigClangStmt_CXXDefaultArgExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDefaultArgExprClass;
-pub const ZigClangStmt_CXXDefaultInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDefaultInitExprClass;
-pub const ZigClangStmt_CXXDeleteExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDeleteExprClass;
-pub const ZigClangStmt_CXXDependentScopeMemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDependentScopeMemberExprClass;
-pub const ZigClangStmt_CXXFoldExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXFoldExprClass;
-pub const ZigClangStmt_CXXInheritedCtorInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXInheritedCtorInitExprClass;
-pub const ZigClangStmt_CXXNewExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNewExprClass;
-pub const ZigClangStmt_CXXNoexceptExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNoexceptExprClass;
-pub const ZigClangStmt_CXXNullPtrLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNullPtrLiteralExprClass;
-pub const ZigClangStmt_CXXPseudoDestructorExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXPseudoDestructorExprClass;
-pub const ZigClangStmt_CXXScalarValueInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXScalarValueInitExprClass;
-pub const ZigClangStmt_CXXStdInitializerListExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXStdInitializerListExprClass;
-pub const ZigClangStmt_CXXThisExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXThisExprClass;
-pub const ZigClangStmt_CXXThrowExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXThrowExprClass;
-pub const ZigClangStmt_CXXTypeidExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTypeidExprClass;
-pub const ZigClangStmt_CXXUnresolvedConstructExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXUnresolvedConstructExprClass;
-pub const ZigClangStmt_CXXUuidofExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXUuidofExprClass;
-pub const ZigClangStmt_CallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CallExprClass;
-pub const ZigClangStmt_CUDAKernelCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CUDAKernelCallExprClass;
-pub const ZigClangStmt_CXXMemberCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXMemberCallExprClass;
-pub const ZigClangStmt_CXXOperatorCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXOperatorCallExprClass;
-pub const ZigClangStmt_UserDefinedLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_UserDefinedLiteralClass;
-pub const ZigClangStmt_CStyleCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CStyleCastExprClass;
-pub const ZigClangStmt_CXXFunctionalCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXFunctionalCastExprClass;
-pub const ZigClangStmt_CXXConstCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXConstCastExprClass;
-pub const ZigClangStmt_CXXDynamicCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDynamicCastExprClass;
-pub const ZigClangStmt_CXXReinterpretCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXReinterpretCastExprClass;
-pub const ZigClangStmt_CXXStaticCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXStaticCastExprClass;
-pub const ZigClangStmt_ObjCBridgedCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBridgedCastExprClass;
-pub const ZigClangStmt_ImplicitCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_ImplicitCastExprClass;
-pub const ZigClangStmt_CharacterLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_CharacterLiteralClass;
-pub const ZigClangStmt_ChooseExprClass = enum_ZigClangStmtClass.ZigClangStmt_ChooseExprClass;
-pub const ZigClangStmt_CompoundLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundLiteralExprClass;
-pub const ZigClangStmt_ConvertVectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ConvertVectorExprClass;
-pub const ZigClangStmt_CoawaitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CoawaitExprClass;
-pub const ZigClangStmt_CoyieldExprClass = enum_ZigClangStmtClass.ZigClangStmt_CoyieldExprClass;
-pub const ZigClangStmt_DeclRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_DeclRefExprClass;
-pub const ZigClangStmt_DependentCoawaitExprClass = enum_ZigClangStmtClass.ZigClangStmt_DependentCoawaitExprClass;
-pub const ZigClangStmt_DependentScopeDeclRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_DependentScopeDeclRefExprClass;
-pub const ZigClangStmt_DesignatedInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_DesignatedInitExprClass;
-pub const ZigClangStmt_DesignatedInitUpdateExprClass = enum_ZigClangStmtClass.ZigClangStmt_DesignatedInitUpdateExprClass;
-pub const ZigClangStmt_ExpressionTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ExpressionTraitExprClass;
-pub const ZigClangStmt_ExtVectorElementExprClass = enum_ZigClangStmtClass.ZigClangStmt_ExtVectorElementExprClass;
-pub const ZigClangStmt_FixedPointLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_FixedPointLiteralClass;
-pub const ZigClangStmt_FloatingLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_FloatingLiteralClass;
-pub const ZigClangStmt_ConstantExprClass = enum_ZigClangStmtClass.ZigClangStmt_ConstantExprClass;
-pub const ZigClangStmt_ExprWithCleanupsClass = enum_ZigClangStmtClass.ZigClangStmt_ExprWithCleanupsClass;
-pub const ZigClangStmt_FunctionParmPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_FunctionParmPackExprClass;
-pub const ZigClangStmt_GNUNullExprClass = enum_ZigClangStmtClass.ZigClangStmt_GNUNullExprClass;
-pub const ZigClangStmt_GenericSelectionExprClass = enum_ZigClangStmtClass.ZigClangStmt_GenericSelectionExprClass;
-pub const ZigClangStmt_ImaginaryLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ImaginaryLiteralClass;
-pub const ZigClangStmt_ImplicitValueInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ImplicitValueInitExprClass;
-pub const ZigClangStmt_InitListExprClass = enum_ZigClangStmtClass.ZigClangStmt_InitListExprClass;
-pub const ZigClangStmt_IntegerLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_IntegerLiteralClass;
-pub const ZigClangStmt_LambdaExprClass = enum_ZigClangStmtClass.ZigClangStmt_LambdaExprClass;
-pub const ZigClangStmt_MSPropertyRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_MSPropertyRefExprClass;
-pub const ZigClangStmt_MSPropertySubscriptExprClass = enum_ZigClangStmtClass.ZigClangStmt_MSPropertySubscriptExprClass;
-pub const ZigClangStmt_MaterializeTemporaryExprClass = enum_ZigClangStmtClass.ZigClangStmt_MaterializeTemporaryExprClass;
-pub const ZigClangStmt_MemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_MemberExprClass;
-pub const ZigClangStmt_NoInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_NoInitExprClass;
-pub const ZigClangStmt_OMPArraySectionExprClass = enum_ZigClangStmtClass.ZigClangStmt_OMPArraySectionExprClass;
-pub const ZigClangStmt_ObjCArrayLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCArrayLiteralClass;
-pub const ZigClangStmt_ObjCAvailabilityCheckExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAvailabilityCheckExprClass;
-pub const ZigClangStmt_ObjCBoolLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBoolLiteralExprClass;
-pub const ZigClangStmt_ObjCBoxedExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBoxedExprClass;
-pub const ZigClangStmt_ObjCDictionaryLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCDictionaryLiteralClass;
-pub const ZigClangStmt_ObjCEncodeExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCEncodeExprClass;
-pub const ZigClangStmt_ObjCIndirectCopyRestoreExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIndirectCopyRestoreExprClass;
-pub const ZigClangStmt_ObjCIsaExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIsaExprClass;
-pub const ZigClangStmt_ObjCIvarRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIvarRefExprClass;
-pub const ZigClangStmt_ObjCMessageExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCMessageExprClass;
-pub const ZigClangStmt_ObjCPropertyRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCPropertyRefExprClass;
-pub const ZigClangStmt_ObjCProtocolExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCProtocolExprClass;
-pub const ZigClangStmt_ObjCSelectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCSelectorExprClass;
-pub const ZigClangStmt_ObjCStringLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCStringLiteralClass;
-pub const ZigClangStmt_ObjCSubscriptRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCSubscriptRefExprClass;
-pub const ZigClangStmt_OffsetOfExprClass = enum_ZigClangStmtClass.ZigClangStmt_OffsetOfExprClass;
-pub const ZigClangStmt_OpaqueValueExprClass = enum_ZigClangStmtClass.ZigClangStmt_OpaqueValueExprClass;
-pub const ZigClangStmt_UnresolvedLookupExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnresolvedLookupExprClass;
-pub const ZigClangStmt_UnresolvedMemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnresolvedMemberExprClass;
-pub const ZigClangStmt_PackExpansionExprClass = enum_ZigClangStmtClass.ZigClangStmt_PackExpansionExprClass;
-pub const ZigClangStmt_ParenExprClass = enum_ZigClangStmtClass.ZigClangStmt_ParenExprClass;
-pub const ZigClangStmt_ParenListExprClass = enum_ZigClangStmtClass.ZigClangStmt_ParenListExprClass;
-pub const ZigClangStmt_PredefinedExprClass = enum_ZigClangStmtClass.ZigClangStmt_PredefinedExprClass;
-pub const ZigClangStmt_PseudoObjectExprClass = enum_ZigClangStmtClass.ZigClangStmt_PseudoObjectExprClass;
-pub const ZigClangStmt_ShuffleVectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ShuffleVectorExprClass;
-pub const ZigClangStmt_SizeOfPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_SizeOfPackExprClass;
-pub const ZigClangStmt_StmtExprClass = enum_ZigClangStmtClass.ZigClangStmt_StmtExprClass;
-pub const ZigClangStmt_StringLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_StringLiteralClass;
-pub const ZigClangStmt_SubstNonTypeTemplateParmExprClass = enum_ZigClangStmtClass.ZigClangStmt_SubstNonTypeTemplateParmExprClass;
-pub const ZigClangStmt_SubstNonTypeTemplateParmPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_SubstNonTypeTemplateParmPackExprClass;
-pub const ZigClangStmt_TypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_TypeTraitExprClass;
-pub const ZigClangStmt_TypoExprClass = enum_ZigClangStmtClass.ZigClangStmt_TypoExprClass;
-pub const ZigClangStmt_UnaryExprOrTypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnaryExprOrTypeTraitExprClass;
-pub const ZigClangStmt_UnaryOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_UnaryOperatorClass;
-pub const ZigClangStmt_VAArgExprClass = enum_ZigClangStmtClass.ZigClangStmt_VAArgExprClass;
-pub const ZigClangStmt_ForStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ForStmtClass;
-pub const ZigClangStmt_GotoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_GotoStmtClass;
-pub const ZigClangStmt_IfStmtClass = enum_ZigClangStmtClass.ZigClangStmt_IfStmtClass;
-pub const ZigClangStmt_IndirectGotoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_IndirectGotoStmtClass;
-pub const ZigClangStmt_LabelStmtClass = enum_ZigClangStmtClass.ZigClangStmt_LabelStmtClass;
-pub const ZigClangStmt_MSDependentExistsStmtClass = enum_ZigClangStmtClass.ZigClangStmt_MSDependentExistsStmtClass;
-pub const ZigClangStmt_NullStmtClass = enum_ZigClangStmtClass.ZigClangStmt_NullStmtClass;
-pub const ZigClangStmt_OMPAtomicDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPAtomicDirectiveClass;
-pub const ZigClangStmt_OMPBarrierDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPBarrierDirectiveClass;
-pub const ZigClangStmt_OMPCancelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCancelDirectiveClass;
-pub const ZigClangStmt_OMPCancellationPointDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCancellationPointDirectiveClass;
-pub const ZigClangStmt_OMPCriticalDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCriticalDirectiveClass;
-pub const ZigClangStmt_OMPFlushDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPFlushDirectiveClass;
-pub const ZigClangStmt_OMPDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeDirectiveClass;
-pub const ZigClangStmt_OMPDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeParallelForDirectiveClass;
-pub const ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass;
-pub const ZigClangStmt_OMPDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeSimdDirectiveClass;
-pub const ZigClangStmt_OMPForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPForDirectiveClass;
-pub const ZigClangStmt_OMPForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPForSimdDirectiveClass;
-pub const ZigClangStmt_OMPParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelForDirectiveClass;
-pub const ZigClangStmt_OMPParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelForSimdDirectiveClass;
-pub const ZigClangStmt_OMPSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSimdDirectiveClass;
-pub const ZigClangStmt_OMPTargetParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelForSimdDirectiveClass;
-pub const ZigClangStmt_OMPTargetSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetSimdDirectiveClass;
-pub const ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass;
-pub const ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass;
-pub const ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass;
-pub const ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass;
-pub const ZigClangStmt_OMPTaskLoopDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskLoopDirectiveClass;
-pub const ZigClangStmt_OMPTaskLoopSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskLoopSimdDirectiveClass;
-pub const ZigClangStmt_OMPTeamsDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeDirectiveClass;
-pub const ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass;
-pub const ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass;
-pub const ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass;
-pub const ZigClangStmt_OMPMasterDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPMasterDirectiveClass;
-pub const ZigClangStmt_OMPOrderedDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPOrderedDirectiveClass;
-pub const ZigClangStmt_OMPParallelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelDirectiveClass;
-pub const ZigClangStmt_OMPParallelSectionsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelSectionsDirectiveClass;
-pub const ZigClangStmt_OMPSectionDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSectionDirectiveClass;
-pub const ZigClangStmt_OMPSectionsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSectionsDirectiveClass;
-pub const ZigClangStmt_OMPSingleDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSingleDirectiveClass;
-pub const ZigClangStmt_OMPTargetDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetDataDirectiveClass;
-pub const ZigClangStmt_OMPTargetDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetDirectiveClass;
-pub const ZigClangStmt_OMPTargetEnterDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetEnterDataDirectiveClass;
-pub const ZigClangStmt_OMPTargetExitDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetExitDataDirectiveClass;
-pub const ZigClangStmt_OMPTargetParallelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelDirectiveClass;
-pub const ZigClangStmt_OMPTargetParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelForDirectiveClass;
-pub const ZigClangStmt_OMPTargetTeamsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDirectiveClass;
-pub const ZigClangStmt_OMPTargetUpdateDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetUpdateDirectiveClass;
-pub const ZigClangStmt_OMPTaskDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskDirectiveClass;
-pub const ZigClangStmt_OMPTaskgroupDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskgroupDirectiveClass;
-pub const ZigClangStmt_OMPTaskwaitDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskwaitDirectiveClass;
-pub const ZigClangStmt_OMPTaskyieldDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskyieldDirectiveClass;
-pub const ZigClangStmt_OMPTeamsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDirectiveClass;
-pub const ZigClangStmt_ObjCAtCatchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtCatchStmtClass;
-pub const ZigClangStmt_ObjCAtFinallyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtFinallyStmtClass;
-pub const ZigClangStmt_ObjCAtSynchronizedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtSynchronizedStmtClass;
-pub const ZigClangStmt_ObjCAtThrowStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtThrowStmtClass;
-pub const ZigClangStmt_ObjCAtTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtTryStmtClass;
-pub const ZigClangStmt_ObjCAutoreleasePoolStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAutoreleasePoolStmtClass;
-pub const ZigClangStmt_ObjCForCollectionStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCForCollectionStmtClass;
-pub const ZigClangStmt_ReturnStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ReturnStmtClass;
-pub const ZigClangStmt_SEHExceptStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHExceptStmtClass;
-pub const ZigClangStmt_SEHFinallyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHFinallyStmtClass;
-pub const ZigClangStmt_SEHLeaveStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHLeaveStmtClass;
-pub const ZigClangStmt_SEHTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHTryStmtClass;
-pub const ZigClangStmt_CaseStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CaseStmtClass;
-pub const ZigClangStmt_DefaultStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DefaultStmtClass;
-pub const ZigClangStmt_SwitchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SwitchStmtClass;
-pub const ZigClangStmt_WhileStmtClass = enum_ZigClangStmtClass.ZigClangStmt_WhileStmtClass;
-pub const enum_ZigClangStmtClass = extern enum {
-    ZigClangStmt_NoStmtClass = 0,
-    ZigClangStmt_GCCAsmStmtClass = 1,
-    ZigClangStmt_MSAsmStmtClass = 2,
-    ZigClangStmt_AttributedStmtClass = 3,
-    ZigClangStmt_BreakStmtClass = 4,
-    ZigClangStmt_CXXCatchStmtClass = 5,
-    ZigClangStmt_CXXForRangeStmtClass = 6,
-    ZigClangStmt_CXXTryStmtClass = 7,
-    ZigClangStmt_CapturedStmtClass = 8,
-    ZigClangStmt_CompoundStmtClass = 9,
-    ZigClangStmt_ContinueStmtClass = 10,
-    ZigClangStmt_CoreturnStmtClass = 11,
-    ZigClangStmt_CoroutineBodyStmtClass = 12,
-    ZigClangStmt_DeclStmtClass = 13,
-    ZigClangStmt_DoStmtClass = 14,
-    ZigClangStmt_BinaryConditionalOperatorClass = 15,
-    ZigClangStmt_ConditionalOperatorClass = 16,
-    ZigClangStmt_AddrLabelExprClass = 17,
-    ZigClangStmt_ArrayInitIndexExprClass = 18,
-    ZigClangStmt_ArrayInitLoopExprClass = 19,
-    ZigClangStmt_ArraySubscriptExprClass = 20,
-    ZigClangStmt_ArrayTypeTraitExprClass = 21,
-    ZigClangStmt_AsTypeExprClass = 22,
-    ZigClangStmt_AtomicExprClass = 23,
-    ZigClangStmt_BinaryOperatorClass = 24,
-    ZigClangStmt_CompoundAssignOperatorClass = 25,
-    ZigClangStmt_BlockExprClass = 26,
-    ZigClangStmt_CXXBindTemporaryExprClass = 27,
-    ZigClangStmt_CXXBoolLiteralExprClass = 28,
-    ZigClangStmt_CXXConstructExprClass = 29,
-    ZigClangStmt_CXXTemporaryObjectExprClass = 30,
-    ZigClangStmt_CXXDefaultArgExprClass = 31,
-    ZigClangStmt_CXXDefaultInitExprClass = 32,
-    ZigClangStmt_CXXDeleteExprClass = 33,
-    ZigClangStmt_CXXDependentScopeMemberExprClass = 34,
-    ZigClangStmt_CXXFoldExprClass = 35,
-    ZigClangStmt_CXXInheritedCtorInitExprClass = 36,
-    ZigClangStmt_CXXNewExprClass = 37,
-    ZigClangStmt_CXXNoexceptExprClass = 38,
-    ZigClangStmt_CXXNullPtrLiteralExprClass = 39,
-    ZigClangStmt_CXXPseudoDestructorExprClass = 40,
-    ZigClangStmt_CXXScalarValueInitExprClass = 41,
-    ZigClangStmt_CXXStdInitializerListExprClass = 42,
-    ZigClangStmt_CXXThisExprClass = 43,
-    ZigClangStmt_CXXThrowExprClass = 44,
-    ZigClangStmt_CXXTypeidExprClass = 45,
-    ZigClangStmt_CXXUnresolvedConstructExprClass = 46,
-    ZigClangStmt_CXXUuidofExprClass = 47,
-    ZigClangStmt_CallExprClass = 48,
-    ZigClangStmt_CUDAKernelCallExprClass = 49,
-    ZigClangStmt_CXXMemberCallExprClass = 50,
-    ZigClangStmt_CXXOperatorCallExprClass = 51,
-    ZigClangStmt_UserDefinedLiteralClass = 52,
-    ZigClangStmt_CStyleCastExprClass = 53,
-    ZigClangStmt_CXXFunctionalCastExprClass = 54,
-    ZigClangStmt_CXXConstCastExprClass = 55,
-    ZigClangStmt_CXXDynamicCastExprClass = 56,
-    ZigClangStmt_CXXReinterpretCastExprClass = 57,
-    ZigClangStmt_CXXStaticCastExprClass = 58,
-    ZigClangStmt_ObjCBridgedCastExprClass = 59,
-    ZigClangStmt_ImplicitCastExprClass = 60,
-    ZigClangStmt_CharacterLiteralClass = 61,
-    ZigClangStmt_ChooseExprClass = 62,
-    ZigClangStmt_CompoundLiteralExprClass = 63,
-    ZigClangStmt_ConvertVectorExprClass = 64,
-    ZigClangStmt_CoawaitExprClass = 65,
-    ZigClangStmt_CoyieldExprClass = 66,
-    ZigClangStmt_DeclRefExprClass = 67,
-    ZigClangStmt_DependentCoawaitExprClass = 68,
-    ZigClangStmt_DependentScopeDeclRefExprClass = 69,
-    ZigClangStmt_DesignatedInitExprClass = 70,
-    ZigClangStmt_DesignatedInitUpdateExprClass = 71,
-    ZigClangStmt_ExpressionTraitExprClass = 72,
-    ZigClangStmt_ExtVectorElementExprClass = 73,
-    ZigClangStmt_FixedPointLiteralClass = 74,
-    ZigClangStmt_FloatingLiteralClass = 75,
-    ZigClangStmt_ConstantExprClass = 76,
-    ZigClangStmt_ExprWithCleanupsClass = 77,
-    ZigClangStmt_FunctionParmPackExprClass = 78,
-    ZigClangStmt_GNUNullExprClass = 79,
-    ZigClangStmt_GenericSelectionExprClass = 80,
-    ZigClangStmt_ImaginaryLiteralClass = 81,
-    ZigClangStmt_ImplicitValueInitExprClass = 82,
-    ZigClangStmt_InitListExprClass = 83,
-    ZigClangStmt_IntegerLiteralClass = 84,
-    ZigClangStmt_LambdaExprClass = 85,
-    ZigClangStmt_MSPropertyRefExprClass = 86,
-    ZigClangStmt_MSPropertySubscriptExprClass = 87,
-    ZigClangStmt_MaterializeTemporaryExprClass = 88,
-    ZigClangStmt_MemberExprClass = 89,
-    ZigClangStmt_NoInitExprClass = 90,
-    ZigClangStmt_OMPArraySectionExprClass = 91,
-    ZigClangStmt_ObjCArrayLiteralClass = 92,
-    ZigClangStmt_ObjCAvailabilityCheckExprClass = 93,
-    ZigClangStmt_ObjCBoolLiteralExprClass = 94,
-    ZigClangStmt_ObjCBoxedExprClass = 95,
-    ZigClangStmt_ObjCDictionaryLiteralClass = 96,
-    ZigClangStmt_ObjCEncodeExprClass = 97,
-    ZigClangStmt_ObjCIndirectCopyRestoreExprClass = 98,
-    ZigClangStmt_ObjCIsaExprClass = 99,
-    ZigClangStmt_ObjCIvarRefExprClass = 100,
-    ZigClangStmt_ObjCMessageExprClass = 101,
-    ZigClangStmt_ObjCPropertyRefExprClass = 102,
-    ZigClangStmt_ObjCProtocolExprClass = 103,
-    ZigClangStmt_ObjCSelectorExprClass = 104,
-    ZigClangStmt_ObjCStringLiteralClass = 105,
-    ZigClangStmt_ObjCSubscriptRefExprClass = 106,
-    ZigClangStmt_OffsetOfExprClass = 107,
-    ZigClangStmt_OpaqueValueExprClass = 108,
-    ZigClangStmt_UnresolvedLookupExprClass = 109,
-    ZigClangStmt_UnresolvedMemberExprClass = 110,
-    ZigClangStmt_PackExpansionExprClass = 111,
-    ZigClangStmt_ParenExprClass = 112,
-    ZigClangStmt_ParenListExprClass = 113,
-    ZigClangStmt_PredefinedExprClass = 114,
-    ZigClangStmt_PseudoObjectExprClass = 115,
-    ZigClangStmt_ShuffleVectorExprClass = 116,
-    ZigClangStmt_SizeOfPackExprClass = 117,
-    ZigClangStmt_StmtExprClass = 118,
-    ZigClangStmt_StringLiteralClass = 119,
-    ZigClangStmt_SubstNonTypeTemplateParmExprClass = 120,
-    ZigClangStmt_SubstNonTypeTemplateParmPackExprClass = 121,
-    ZigClangStmt_TypeTraitExprClass = 122,
-    ZigClangStmt_TypoExprClass = 123,
-    ZigClangStmt_UnaryExprOrTypeTraitExprClass = 124,
-    ZigClangStmt_UnaryOperatorClass = 125,
-    ZigClangStmt_VAArgExprClass = 126,
-    ZigClangStmt_ForStmtClass = 127,
-    ZigClangStmt_GotoStmtClass = 128,
-    ZigClangStmt_IfStmtClass = 129,
-    ZigClangStmt_IndirectGotoStmtClass = 130,
-    ZigClangStmt_LabelStmtClass = 131,
-    ZigClangStmt_MSDependentExistsStmtClass = 132,
-    ZigClangStmt_NullStmtClass = 133,
-    ZigClangStmt_OMPAtomicDirectiveClass = 134,
-    ZigClangStmt_OMPBarrierDirectiveClass = 135,
-    ZigClangStmt_OMPCancelDirectiveClass = 136,
-    ZigClangStmt_OMPCancellationPointDirectiveClass = 137,
-    ZigClangStmt_OMPCriticalDirectiveClass = 138,
-    ZigClangStmt_OMPFlushDirectiveClass = 139,
-    ZigClangStmt_OMPDistributeDirectiveClass = 140,
-    ZigClangStmt_OMPDistributeParallelForDirectiveClass = 141,
-    ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass = 142,
-    ZigClangStmt_OMPDistributeSimdDirectiveClass = 143,
-    ZigClangStmt_OMPForDirectiveClass = 144,
-    ZigClangStmt_OMPForSimdDirectiveClass = 145,
-    ZigClangStmt_OMPParallelForDirectiveClass = 146,
-    ZigClangStmt_OMPParallelForSimdDirectiveClass = 147,
-    ZigClangStmt_OMPSimdDirectiveClass = 148,
-    ZigClangStmt_OMPTargetParallelForSimdDirectiveClass = 149,
-    ZigClangStmt_OMPTargetSimdDirectiveClass = 150,
-    ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass = 151,
-    ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass = 152,
-    ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass = 153,
-    ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass = 154,
-    ZigClangStmt_OMPTaskLoopDirectiveClass = 155,
-    ZigClangStmt_OMPTaskLoopSimdDirectiveClass = 156,
-    ZigClangStmt_OMPTeamsDistributeDirectiveClass = 157,
-    ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass = 158,
-    ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass = 159,
-    ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass = 160,
-    ZigClangStmt_OMPMasterDirectiveClass = 161,
-    ZigClangStmt_OMPOrderedDirectiveClass = 162,
-    ZigClangStmt_OMPParallelDirectiveClass = 163,
-    ZigClangStmt_OMPParallelSectionsDirectiveClass = 164,
-    ZigClangStmt_OMPSectionDirectiveClass = 165,
-    ZigClangStmt_OMPSectionsDirectiveClass = 166,
-    ZigClangStmt_OMPSingleDirectiveClass = 167,
-    ZigClangStmt_OMPTargetDataDirectiveClass = 168,
-    ZigClangStmt_OMPTargetDirectiveClass = 169,
-    ZigClangStmt_OMPTargetEnterDataDirectiveClass = 170,
-    ZigClangStmt_OMPTargetExitDataDirectiveClass = 171,
-    ZigClangStmt_OMPTargetParallelDirectiveClass = 172,
-    ZigClangStmt_OMPTargetParallelForDirectiveClass = 173,
-    ZigClangStmt_OMPTargetTeamsDirectiveClass = 174,
-    ZigClangStmt_OMPTargetUpdateDirectiveClass = 175,
-    ZigClangStmt_OMPTaskDirectiveClass = 176,
-    ZigClangStmt_OMPTaskgroupDirectiveClass = 177,
-    ZigClangStmt_OMPTaskwaitDirectiveClass = 178,
-    ZigClangStmt_OMPTaskyieldDirectiveClass = 179,
-    ZigClangStmt_OMPTeamsDirectiveClass = 180,
-    ZigClangStmt_ObjCAtCatchStmtClass = 181,
-    ZigClangStmt_ObjCAtFinallyStmtClass = 182,
-    ZigClangStmt_ObjCAtSynchronizedStmtClass = 183,
-    ZigClangStmt_ObjCAtThrowStmtClass = 184,
-    ZigClangStmt_ObjCAtTryStmtClass = 185,
-    ZigClangStmt_ObjCAutoreleasePoolStmtClass = 186,
-    ZigClangStmt_ObjCForCollectionStmtClass = 187,
-    ZigClangStmt_ReturnStmtClass = 188,
-    ZigClangStmt_SEHExceptStmtClass = 189,
-    ZigClangStmt_SEHFinallyStmtClass = 190,
-    ZigClangStmt_SEHLeaveStmtClass = 191,
-    ZigClangStmt_SEHTryStmtClass = 192,
-    ZigClangStmt_CaseStmtClass = 193,
-    ZigClangStmt_DefaultStmtClass = 194,
-    ZigClangStmt_SwitchStmtClass = 195,
-    ZigClangStmt_WhileStmtClass = 196,
+
+pub const ZigClangStmtClass = extern enum {
+    NoStmtClass = 0,
+    GCCAsmStmtClass = 1,
+    MSAsmStmtClass = 2,
+    AttributedStmtClass = 3,
+    BreakStmtClass = 4,
+    CXXCatchStmtClass = 5,
+    CXXForRangeStmtClass = 6,
+    CXXTryStmtClass = 7,
+    CapturedStmtClass = 8,
+    CompoundStmtClass = 9,
+    ContinueStmtClass = 10,
+    CoreturnStmtClass = 11,
+    CoroutineBodyStmtClass = 12,
+    DeclStmtClass = 13,
+    DoStmtClass = 14,
+    BinaryConditionalOperatorClass = 15,
+    ConditionalOperatorClass = 16,
+    AddrLabelExprClass = 17,
+    ArrayInitIndexExprClass = 18,
+    ArrayInitLoopExprClass = 19,
+    ArraySubscriptExprClass = 20,
+    ArrayTypeTraitExprClass = 21,
+    AsTypeExprClass = 22,
+    AtomicExprClass = 23,
+    BinaryOperatorClass = 24,
+    CompoundAssignOperatorClass = 25,
+    BlockExprClass = 26,
+    CXXBindTemporaryExprClass = 27,
+    CXXBoolLiteralExprClass = 28,
+    CXXConstructExprClass = 29,
+    CXXTemporaryObjectExprClass = 30,
+    CXXDefaultArgExprClass = 31,
+    CXXDefaultInitExprClass = 32,
+    CXXDeleteExprClass = 33,
+    CXXDependentScopeMemberExprClass = 34,
+    CXXFoldExprClass = 35,
+    CXXInheritedCtorInitExprClass = 36,
+    CXXNewExprClass = 37,
+    CXXNoexceptExprClass = 38,
+    CXXNullPtrLiteralExprClass = 39,
+    CXXPseudoDestructorExprClass = 40,
+    CXXScalarValueInitExprClass = 41,
+    CXXStdInitializerListExprClass = 42,
+    CXXThisExprClass = 43,
+    CXXThrowExprClass = 44,
+    CXXTypeidExprClass = 45,
+    CXXUnresolvedConstructExprClass = 46,
+    CXXUuidofExprClass = 47,
+    CallExprClass = 48,
+    CUDAKernelCallExprClass = 49,
+    CXXMemberCallExprClass = 50,
+    CXXOperatorCallExprClass = 51,
+    UserDefinedLiteralClass = 52,
+    CStyleCastExprClass = 53,
+    CXXFunctionalCastExprClass = 54,
+    CXXConstCastExprClass = 55,
+    CXXDynamicCastExprClass = 56,
+    CXXReinterpretCastExprClass = 57,
+    CXXStaticCastExprClass = 58,
+    ObjCBridgedCastExprClass = 59,
+    ImplicitCastExprClass = 60,
+    CharacterLiteralClass = 61,
+    ChooseExprClass = 62,
+    CompoundLiteralExprClass = 63,
+    ConvertVectorExprClass = 64,
+    CoawaitExprClass = 65,
+    CoyieldExprClass = 66,
+    DeclRefExprClass = 67,
+    DependentCoawaitExprClass = 68,
+    DependentScopeDeclRefExprClass = 69,
+    DesignatedInitExprClass = 70,
+    DesignatedInitUpdateExprClass = 71,
+    ExpressionTraitExprClass = 72,
+    ExtVectorElementExprClass = 73,
+    FixedPointLiteralClass = 74,
+    FloatingLiteralClass = 75,
+    ConstantExprClass = 76,
+    ExprWithCleanupsClass = 77,
+    FunctionParmPackExprClass = 78,
+    GNUNullExprClass = 79,
+    GenericSelectionExprClass = 80,
+    ImaginaryLiteralClass = 81,
+    ImplicitValueInitExprClass = 82,
+    InitListExprClass = 83,
+    IntegerLiteralClass = 84,
+    LambdaExprClass = 85,
+    MSPropertyRefExprClass = 86,
+    MSPropertySubscriptExprClass = 87,
+    MaterializeTemporaryExprClass = 88,
+    MemberExprClass = 89,
+    NoInitExprClass = 90,
+    OMPArraySectionExprClass = 91,
+    ObjCArrayLiteralClass = 92,
+    ObjCAvailabilityCheckExprClass = 93,
+    ObjCBoolLiteralExprClass = 94,
+    ObjCBoxedExprClass = 95,
+    ObjCDictionaryLiteralClass = 96,
+    ObjCEncodeExprClass = 97,
+    ObjCIndirectCopyRestoreExprClass = 98,
+    ObjCIsaExprClass = 99,
+    ObjCIvarRefExprClass = 100,
+    ObjCMessageExprClass = 101,
+    ObjCPropertyRefExprClass = 102,
+    ObjCProtocolExprClass = 103,
+    ObjCSelectorExprClass = 104,
+    ObjCStringLiteralClass = 105,
+    ObjCSubscriptRefExprClass = 106,
+    OffsetOfExprClass = 107,
+    OpaqueValueExprClass = 108,
+    UnresolvedLookupExprClass = 109,
+    UnresolvedMemberExprClass = 110,
+    PackExpansionExprClass = 111,
+    ParenExprClass = 112,
+    ParenListExprClass = 113,
+    PredefinedExprClass = 114,
+    PseudoObjectExprClass = 115,
+    ShuffleVectorExprClass = 116,
+    SizeOfPackExprClass = 117,
+    StmtExprClass = 118,
+    StringLiteralClass = 119,
+    SubstNonTypeTemplateParmExprClass = 120,
+    SubstNonTypeTemplateParmPackExprClass = 121,
+    TypeTraitExprClass = 122,
+    TypoExprClass = 123,
+    UnaryExprOrTypeTraitExprClass = 124,
+    UnaryOperatorClass = 125,
+    VAArgExprClass = 126,
+    ForStmtClass = 127,
+    GotoStmtClass = 128,
+    IfStmtClass = 129,
+    IndirectGotoStmtClass = 130,
+    LabelStmtClass = 131,
+    MSDependentExistsStmtClass = 132,
+    NullStmtClass = 133,
+    OMPAtomicDirectiveClass = 134,
+    OMPBarrierDirectiveClass = 135,
+    OMPCancelDirectiveClass = 136,
+    OMPCancellationPointDirectiveClass = 137,
+    OMPCriticalDirectiveClass = 138,
+    OMPFlushDirectiveClass = 139,
+    OMPDistributeDirectiveClass = 140,
+    OMPDistributeParallelForDirectiveClass = 141,
+    OMPDistributeParallelForSimdDirectiveClass = 142,
+    OMPDistributeSimdDirectiveClass = 143,
+    OMPForDirectiveClass = 144,
+    OMPForSimdDirectiveClass = 145,
+    OMPParallelForDirectiveClass = 146,
+    OMPParallelForSimdDirectiveClass = 147,
+    OMPSimdDirectiveClass = 148,
+    OMPTargetParallelForSimdDirectiveClass = 149,
+    OMPTargetSimdDirectiveClass = 150,
+    OMPTargetTeamsDistributeDirectiveClass = 151,
+    OMPTargetTeamsDistributeParallelForDirectiveClass = 152,
+    OMPTargetTeamsDistributeParallelForSimdDirectiveClass = 153,
+    OMPTargetTeamsDistributeSimdDirectiveClass = 154,
+    OMPTaskLoopDirectiveClass = 155,
+    OMPTaskLoopSimdDirectiveClass = 156,
+    OMPTeamsDistributeDirectiveClass = 157,
+    OMPTeamsDistributeParallelForDirectiveClass = 158,
+    OMPTeamsDistributeParallelForSimdDirectiveClass = 159,
+    OMPTeamsDistributeSimdDirectiveClass = 160,
+    OMPMasterDirectiveClass = 161,
+    OMPOrderedDirectiveClass = 162,
+    OMPParallelDirectiveClass = 163,
+    OMPParallelSectionsDirectiveClass = 164,
+    OMPSectionDirectiveClass = 165,
+    OMPSectionsDirectiveClass = 166,
+    OMPSingleDirectiveClass = 167,
+    OMPTargetDataDirectiveClass = 168,
+    OMPTargetDirectiveClass = 169,
+    OMPTargetEnterDataDirectiveClass = 170,
+    OMPTargetExitDataDirectiveClass = 171,
+    OMPTargetParallelDirectiveClass = 172,
+    OMPTargetParallelForDirectiveClass = 173,
+    OMPTargetTeamsDirectiveClass = 174,
+    OMPTargetUpdateDirectiveClass = 175,
+    OMPTaskDirectiveClass = 176,
+    OMPTaskgroupDirectiveClass = 177,
+    OMPTaskwaitDirectiveClass = 178,
+    OMPTaskyieldDirectiveClass = 179,
+    OMPTeamsDirectiveClass = 180,
+    ObjCAtCatchStmtClass = 181,
+    ObjCAtFinallyStmtClass = 182,
+    ObjCAtSynchronizedStmtClass = 183,
+    ObjCAtThrowStmtClass = 184,
+    ObjCAtTryStmtClass = 185,
+    ObjCAutoreleasePoolStmtClass = 186,
+    ObjCForCollectionStmtClass = 187,
+    ReturnStmtClass = 188,
+    SEHExceptStmtClass = 189,
+    SEHFinallyStmtClass = 190,
+    SEHLeaveStmtClass = 191,
+    SEHTryStmtClass = 192,
+    CaseStmtClass = 193,
+    DefaultStmtClass = 194,
+    SwitchStmtClass = 195,
+    WhileStmtClass = 196,
 };
-pub const ZigClangCK_Dependent = enum_ZigClangCK._Dependent;
-pub const ZigClangCK_BitCast = enum_ZigClangCK._BitCast;
-pub const ZigClangCK_LValueBitCast = enum_ZigClangCK._LValueBitCast;
-pub const ZigClangCK_LValueToRValue = enum_ZigClangCK._LValueToRValue;
-pub const ZigClangCK_NoOp = enum_ZigClangCK._NoOp;
-pub const ZigClangCK_BaseToDerived = enum_ZigClangCK._BaseToDerived;
-pub const ZigClangCK_DerivedToBase = enum_ZigClangCK._DerivedToBase;
-pub const ZigClangCK_UncheckedDerivedToBase = enum_ZigClangCK._UncheckedDerivedToBase;
-pub const ZigClangCK_Dynamic = enum_ZigClangCK._Dynamic;
-pub const ZigClangCK_ToUnion = enum_ZigClangCK._ToUnion;
-pub const ZigClangCK_ArrayToPointerDecay = enum_ZigClangCK._ArrayToPointerDecay;
-pub const ZigClangCK_FunctionToPointerDecay = enum_ZigClangCK._FunctionToPointerDecay;
-pub const ZigClangCK_NullToPointer = enum_ZigClangCK._NullToPointer;
-pub const ZigClangCK_NullToMemberPointer = enum_ZigClangCK._NullToMemberPointer;
-pub const ZigClangCK_BaseToDerivedMemberPointer = enum_ZigClangCK._BaseToDerivedMemberPointer;
-pub const ZigClangCK_DerivedToBaseMemberPointer = enum_ZigClangCK._DerivedToBaseMemberPointer;
-pub const ZigClangCK_MemberPointerToBoolean = enum_ZigClangCK._MemberPointerToBoolean;
-pub const ZigClangCK_ReinterpretMemberPointer = enum_ZigClangCK._ReinterpretMemberPointer;
-pub const ZigClangCK_UserDefinedConversion = enum_ZigClangCK._UserDefinedConversion;
-pub const ZigClangCK_ConstructorConversion = enum_ZigClangCK._ConstructorConversion;
-pub const ZigClangCK_IntegralToPointer = enum_ZigClangCK._IntegralToPointer;
-pub const ZigClangCK_PointerToIntegral = enum_ZigClangCK._PointerToIntegral;
-pub const ZigClangCK_PointerToBoolean = enum_ZigClangCK._PointerToBoolean;
-pub const ZigClangCK_ToVoid = enum_ZigClangCK._ToVoid;
-pub const ZigClangCK_VectorSplat = enum_ZigClangCK._VectorSplat;
-pub const ZigClangCK_IntegralCast = enum_ZigClangCK._IntegralCast;
-pub const ZigClangCK_IntegralToBoolean = enum_ZigClangCK._IntegralToBoolean;
-pub const ZigClangCK_IntegralToFloating = enum_ZigClangCK._IntegralToFloating;
-pub const ZigClangCK_FixedPointCast = enum_ZigClangCK._FixedPointCast;
-pub const ZigClangCK_FixedPointToBoolean = enum_ZigClangCK._FixedPointToBoolean;
-pub const ZigClangCK_FloatingToIntegral = enum_ZigClangCK._FloatingToIntegral;
-pub const ZigClangCK_FloatingToBoolean = enum_ZigClangCK._FloatingToBoolean;
-pub const ZigClangCK_BooleanToSignedIntegral = enum_ZigClangCK._BooleanToSignedIntegral;
-pub const ZigClangCK_FloatingCast = enum_ZigClangCK._FloatingCast;
-pub const ZigClangCK_CPointerToObjCPointerCast = enum_ZigClangCK._CPointerToObjCPointerCast;
-pub const ZigClangCK_BlockPointerToObjCPointerCast = enum_ZigClangCK._BlockPointerToObjCPointerCast;
-pub const ZigClangCK_AnyPointerToBlockPointerCast = enum_ZigClangCK._AnyPointerToBlockPointerCast;
-pub const ZigClangCK_ObjCObjectLValueCast = enum_ZigClangCK._ObjCObjectLValueCast;
-pub const ZigClangCK_FloatingRealToComplex = enum_ZigClangCK._FloatingRealToComplex;
-pub const ZigClangCK_FloatingComplexToReal = enum_ZigClangCK._FloatingComplexToReal;
-pub const ZigClangCK_FloatingComplexToBoolean = enum_ZigClangCK._FloatingComplexToBoolean;
-pub const ZigClangCK_FloatingComplexCast = enum_ZigClangCK._FloatingComplexCast;
-pub const ZigClangCK_FloatingComplexToIntegralComplex = enum_ZigClangCK._FloatingComplexToIntegralComplex;
-pub const ZigClangCK_IntegralRealToComplex = enum_ZigClangCK._IntegralRealToComplex;
-pub const ZigClangCK_IntegralComplexToReal = enum_ZigClangCK._IntegralComplexToReal;
-pub const ZigClangCK_IntegralComplexToBoolean = enum_ZigClangCK._IntegralComplexToBoolean;
-pub const ZigClangCK_IntegralComplexCast = enum_ZigClangCK._IntegralComplexCast;
-pub const ZigClangCK_IntegralComplexToFloatingComplex = enum_ZigClangCK._IntegralComplexToFloatingComplex;
-pub const ZigClangCK_ARCProduceObject = enum_ZigClangCK._ARCProduceObject;
-pub const ZigClangCK_ARCConsumeObject = enum_ZigClangCK._ARCConsumeObject;
-pub const ZigClangCK_ARCReclaimReturnedObject = enum_ZigClangCK._ARCReclaimReturnedObject;
-pub const ZigClangCK_ARCExtendBlockObject = enum_ZigClangCK._ARCExtendBlockObject;
-pub const ZigClangCK_AtomicToNonAtomic = enum_ZigClangCK._AtomicToNonAtomic;
-pub const ZigClangCK_NonAtomicToAtomic = enum_ZigClangCK._NonAtomicToAtomic;
-pub const ZigClangCK_CopyAndAutoreleaseBlockObject = enum_ZigClangCK._CopyAndAutoreleaseBlockObject;
-pub const ZigClangCK_BuiltinFnToFnPtr = enum_ZigClangCK._BuiltinFnToFnPtr;
-pub const ZigClangCK_ZeroToOCLOpaqueType = enum_ZigClangCK._ZeroToOCLOpaqueType;
-pub const ZigClangCK_AddressSpaceConversion = enum_ZigClangCK._AddressSpaceConversion;
-pub const ZigClangCK_IntToOCLSampler = enum_ZigClangCK._IntToOCLSampler;
-pub const enum_ZigClangCK = extern enum {
-    _Dependent,
-    _BitCast,
-    _LValueBitCast,
-    _LValueToRValue,
-    _NoOp,
-    _BaseToDerived,
-    _DerivedToBase,
-    _UncheckedDerivedToBase,
-    _Dynamic,
-    _ToUnion,
-    _ArrayToPointerDecay,
-    _FunctionToPointerDecay,
-    _NullToPointer,
-    _NullToMemberPointer,
-    _BaseToDerivedMemberPointer,
-    _DerivedToBaseMemberPointer,
-    _MemberPointerToBoolean,
-    _ReinterpretMemberPointer,
-    _UserDefinedConversion,
-    _ConstructorConversion,
-    _IntegralToPointer,
-    _PointerToIntegral,
-    _PointerToBoolean,
-    _ToVoid,
-    _VectorSplat,
-    _IntegralCast,
-    _IntegralToBoolean,
-    _IntegralToFloating,
-    _FixedPointCast,
-    _FixedPointToBoolean,
-    _FloatingToIntegral,
-    _FloatingToBoolean,
-    _BooleanToSignedIntegral,
-    _FloatingCast,
-    _CPointerToObjCPointerCast,
-    _BlockPointerToObjCPointerCast,
-    _AnyPointerToBlockPointerCast,
-    _ObjCObjectLValueCast,
-    _FloatingRealToComplex,
-    _FloatingComplexToReal,
-    _FloatingComplexToBoolean,
-    _FloatingComplexCast,
-    _FloatingComplexToIntegralComplex,
-    _IntegralRealToComplex,
-    _IntegralComplexToReal,
-    _IntegralComplexToBoolean,
-    _IntegralComplexCast,
-    _IntegralComplexToFloatingComplex,
-    _ARCProduceObject,
-    _ARCConsumeObject,
-    _ARCReclaimReturnedObject,
-    _ARCExtendBlockObject,
-    _AtomicToNonAtomic,
-    _NonAtomicToAtomic,
-    _CopyAndAutoreleaseBlockObject,
-    _BuiltinFnToFnPtr,
-    _ZeroToOCLOpaqueType,
-    _AddressSpaceConversion,
-    _IntToOCLSampler,
+
+pub const ZigClangCK = extern enum {
+    Dependent,
+    BitCast,
+    LValueBitCast,
+    LValueToRValue,
+    NoOp,
+    BaseToDerived,
+    DerivedToBase,
+    UncheckedDerivedToBase,
+    Dynamic,
+    ToUnion,
+    ArrayToPointerDecay,
+    FunctionToPointerDecay,
+    NullToPointer,
+    NullToMemberPointer,
+    BaseToDerivedMemberPointer,
+    DerivedToBaseMemberPointer,
+    MemberPointerToBoolean,
+    ReinterpretMemberPointer,
+    UserDefinedConversion,
+    ConstructorConversion,
+    IntegralToPointer,
+    PointerToIntegral,
+    PointerToBoolean,
+    ToVoid,
+    VectorSplat,
+    IntegralCast,
+    IntegralToBoolean,
+    IntegralToFloating,
+    FixedPointCast,
+    FixedPointToBoolean,
+    FloatingToIntegral,
+    FloatingToBoolean,
+    BooleanToSignedIntegral,
+    FloatingCast,
+    CPointerToObjCPointerCast,
+    BlockPointerToObjCPointerCast,
+    AnyPointerToBlockPointerCast,
+    ObjCObjectLValueCast,
+    FloatingRealToComplex,
+    FloatingComplexToReal,
+    FloatingComplexToBoolean,
+    FloatingComplexCast,
+    FloatingComplexToIntegralComplex,
+    IntegralRealToComplex,
+    IntegralComplexToReal,
+    IntegralComplexToBoolean,
+    IntegralComplexCast,
+    IntegralComplexToFloatingComplex,
+    ARCProduceObject,
+    ARCConsumeObject,
+    ARCReclaimReturnedObject,
+    ARCExtendBlockObject,
+    AtomicToNonAtomic,
+    NonAtomicToAtomic,
+    CopyAndAutoreleaseBlockObject,
+    BuiltinFnToFnPtr,
+    ZeroToOCLOpaqueType,
+    AddressSpaceConversion,
+    IntToOCLSampler,
 };
-pub const ZigClangAPValueUninitialized = enum_ZigClangAPValueKind.ZigClangAPValueUninitialized;
-pub const ZigClangAPValueInt = enum_ZigClangAPValueKind.ZigClangAPValueInt;
-pub const ZigClangAPValueFloat = enum_ZigClangAPValueKind.ZigClangAPValueFloat;
-pub const ZigClangAPValueComplexInt = enum_ZigClangAPValueKind.ZigClangAPValueComplexInt;
-pub const ZigClangAPValueComplexFloat = enum_ZigClangAPValueKind.ZigClangAPValueComplexFloat;
-pub const ZigClangAPValueLValue = enum_ZigClangAPValueKind.ZigClangAPValueLValue;
-pub const ZigClangAPValueVector = enum_ZigClangAPValueKind.ZigClangAPValueVector;
-pub const ZigClangAPValueArray = enum_ZigClangAPValueKind.ZigClangAPValueArray;
-pub const ZigClangAPValueStruct = enum_ZigClangAPValueKind.ZigClangAPValueStruct;
-pub const ZigClangAPValueUnion = enum_ZigClangAPValueKind.ZigClangAPValueUnion;
-pub const ZigClangAPValueMemberPointer = enum_ZigClangAPValueKind.ZigClangAPValueMemberPointer;
-pub const ZigClangAPValueAddrLabelDiff = enum_ZigClangAPValueKind.ZigClangAPValueAddrLabelDiff;
-pub const enum_ZigClangAPValueKind = extern enum {
-    ZigClangAPValueUninitialized,
-    ZigClangAPValueInt,
-    ZigClangAPValueFloat,
-    ZigClangAPValueComplexInt,
-    ZigClangAPValueComplexFloat,
-    ZigClangAPValueLValue,
-    ZigClangAPValueVector,
-    ZigClangAPValueArray,
-    ZigClangAPValueStruct,
-    ZigClangAPValueUnion,
-    ZigClangAPValueMemberPointer,
-    ZigClangAPValueAddrLabelDiff,
+
+pub const ZigClangAPValueKind = extern enum {
+    Uninitialized,
+    Int,
+    Float,
+    ComplexInt,
+    ComplexFloat,
+    LValue,
+    Vector,
+    Array,
+    Struct,
+    Union,
+    MemberPointer,
+    AddrLabelDiff,
 };
+
 pub extern fn ZigClangSourceManager_getSpellingLoc(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation;
 pub extern fn ZigClangSourceManager_getFilename(self: *const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) ?[*]const u8;
 pub extern fn ZigClangSourceManager_getSpellingLineNumber(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
@@ -840,16 +486,16 @@ pub extern fn ZigClangQualType_eq(arg0: struct_ZigClangQualType, arg1: struct_Zi
 pub extern fn ZigClangQualType_isConstQualified(arg0: struct_ZigClangQualType) bool;
 pub extern fn ZigClangQualType_isVolatileQualified(arg0: struct_ZigClangQualType) bool;
 pub extern fn ZigClangQualType_isRestrictQualified(arg0: struct_ZigClangQualType) bool;
-pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) enum_ZigClangTypeClass;
+pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) ZigClangTypeClass;
 pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool;
 pub extern fn ZigClangType_getTypeClassName(self: *const struct_ZigClangType) [*]const u8;
 pub extern fn ZigClangStmt_getBeginLoc(self: ?*const struct_ZigClangStmt) struct_ZigClangSourceLocation;
-pub extern fn ZigClangStmt_getStmtClass(self: ?*const struct_ZigClangStmt) enum_ZigClangStmtClass;
+pub extern fn ZigClangStmt_getStmtClass(self: ?*const struct_ZigClangStmt) ZigClangStmtClass;
 pub extern fn ZigClangStmt_classof_Expr(self: ?*const struct_ZigClangStmt) bool;
-pub extern fn ZigClangExpr_getStmtClass(self: ?*const struct_ZigClangExpr) enum_ZigClangStmtClass;
+pub extern fn ZigClangExpr_getStmtClass(self: ?*const struct_ZigClangExpr) ZigClangStmtClass;
 pub extern fn ZigClangExpr_getType(self: ?*const struct_ZigClangExpr) struct_ZigClangQualType;
 pub extern fn ZigClangExpr_getBeginLoc(self: ?*const struct_ZigClangExpr) struct_ZigClangSourceLocation;
-pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) enum_ZigClangAPValueKind;
+pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) ZigClangAPValueKind;
 pub extern fn ZigClangAPValue_getInt(self: ?*const struct_ZigClangAPValue) ?*const struct_ZigClangAPSInt;
 pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint;
 pub extern fn ZigClangAPValue_getArrayInitializedElt(self: ?*const struct_ZigClangAPValue, i: c_uint) ?*const struct_ZigClangAPValue;
@@ -867,6 +513,11 @@ pub extern fn ZigClangASTUnit_delete(arg0: ?*struct_ZigClangASTUnit) void;
 
 pub extern fn ZigClangFunctionDecl_getType(self: *const struct_ZigClangFunctionDecl) struct_ZigClangQualType;
 pub extern fn ZigClangFunctionDecl_getLocation(self: *const struct_ZigClangFunctionDecl) struct_ZigClangSourceLocation;
+pub extern fn ZigClangBuiltinType_getKind(self: *const struct_ZigClangBuiltinType) ZigClangBuiltinTypeKind;
+
+pub extern fn ZigClangFunctionType_getNoReturnAttr(self: *const ZigClangFunctionType) bool;
+pub extern fn ZigClangFunctionType_getCallConv(self: *const ZigClangFunctionType) ZigClangCallingConv;
+pub extern fn ZigClangFunctionType_getReturnType(self: *const ZigClangFunctionType) ZigClangQualType;
 
 pub const ZigClangSourceLocation = struct_ZigClangSourceLocation;
 pub const ZigClangQualType = struct_ZigClangQualType;
@@ -942,12 +593,6 @@ pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator;
 pub const ZigClangValueDecl = struct_ZigClangValueDecl;
 pub const ZigClangVarDecl = struct_ZigClangVarDecl;
 pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
-pub const ZigClangBO = enum_ZigClangBO;
-pub const ZigClangUO = enum_ZigClangUO;
-pub const ZigClangTypeClass = enum_ZigClangTypeClass;
-pub const ZigClangStmtClass = enum_ZigClangStmtClass;
-pub const ZigClangCK = enum_ZigClangCK;
-pub const ZigClangAPValueKind = enum_ZigClangAPValueKind;
 
 pub const struct_ZigClangSourceLocation = extern struct {
     ID: c_uint,
@@ -1060,3 +705,143 @@ pub const ZigClangDeclKind = extern enum {
 pub const struct_ZigClangQualType = extern struct {
     ptr: ?*c_void,
 };
+
+pub const ZigClangBuiltinTypeKind = extern enum {
+    OCLImage1dRO,
+    OCLImage1dArrayRO,
+    OCLImage1dBufferRO,
+    OCLImage2dRO,
+    OCLImage2dArrayRO,
+    OCLImage2dDepthRO,
+    OCLImage2dArrayDepthRO,
+    OCLImage2dMSAARO,
+    OCLImage2dArrayMSAARO,
+    OCLImage2dMSAADepthRO,
+    OCLImage2dArrayMSAADepthRO,
+    OCLImage3dRO,
+    OCLImage1dWO,
+    OCLImage1dArrayWO,
+    OCLImage1dBufferWO,
+    OCLImage2dWO,
+    OCLImage2dArrayWO,
+    OCLImage2dDepthWO,
+    OCLImage2dArrayDepthWO,
+    OCLImage2dMSAAWO,
+    OCLImage2dArrayMSAAWO,
+    OCLImage2dMSAADepthWO,
+    OCLImage2dArrayMSAADepthWO,
+    OCLImage3dWO,
+    OCLImage1dRW,
+    OCLImage1dArrayRW,
+    OCLImage1dBufferRW,
+    OCLImage2dRW,
+    OCLImage2dArrayRW,
+    OCLImage2dDepthRW,
+    OCLImage2dArrayDepthRW,
+    OCLImage2dMSAARW,
+    OCLImage2dArrayMSAARW,
+    OCLImage2dMSAADepthRW,
+    OCLImage2dArrayMSAADepthRW,
+    OCLImage3dRW,
+    OCLIntelSubgroupAVCMcePayload,
+    OCLIntelSubgroupAVCImePayload,
+    OCLIntelSubgroupAVCRefPayload,
+    OCLIntelSubgroupAVCSicPayload,
+    OCLIntelSubgroupAVCMceResult,
+    OCLIntelSubgroupAVCImeResult,
+    OCLIntelSubgroupAVCRefResult,
+    OCLIntelSubgroupAVCSicResult,
+    OCLIntelSubgroupAVCImeResultSingleRefStreamout,
+    OCLIntelSubgroupAVCImeResultDualRefStreamout,
+    OCLIntelSubgroupAVCImeSingleRefStreamin,
+    OCLIntelSubgroupAVCImeDualRefStreamin,
+    Void,
+    Bool,
+    Char_U,
+    UChar,
+    WChar_U,
+    Char8,
+    Char16,
+    Char32,
+    UShort,
+    UInt,
+    ULong,
+    ULongLong,
+    UInt128,
+    Char_S,
+    SChar,
+    WChar_S,
+    Short,
+    Int,
+    Long,
+    LongLong,
+    Int128,
+    ShortAccum,
+    Accum,
+    LongAccum,
+    UShortAccum,
+    UAccum,
+    ULongAccum,
+    ShortFract,
+    Fract,
+    LongFract,
+    UShortFract,
+    UFract,
+    ULongFract,
+    SatShortAccum,
+    SatAccum,
+    SatLongAccum,
+    SatUShortAccum,
+    SatUAccum,
+    SatULongAccum,
+    SatShortFract,
+    SatFract,
+    SatLongFract,
+    SatUShortFract,
+    SatUFract,
+    SatULongFract,
+    Half,
+    Float,
+    Double,
+    LongDouble,
+    Float16,
+    Float128,
+    NullPtr,
+    ObjCId,
+    ObjCClass,
+    ObjCSel,
+    OCLSampler,
+    OCLEvent,
+    OCLClkEvent,
+    OCLQueue,
+    OCLReserveID,
+    Dependent,
+    Overload,
+    BoundMember,
+    PseudoObject,
+    UnknownAny,
+    BuiltinFn,
+    ARCUnbridgedCast,
+    OMPArraySection,
+};
+
+pub const ZigClangCallingConv = extern enum {
+    C,
+    X86StdCall,
+    X86FastCall,
+    X86ThisCall,
+    X86VectorCall,
+    X86Pascal,
+    Win64,
+    X86_64SysV,
+    X86RegCall,
+    AAPCS,
+    AAPCS_VFP,
+    IntelOclBicc,
+    SpirFunction,
+    OpenCLKernel,
+    Swift,
+    PreserveMost,
+    PreserveAll,
+    AArch64VectorCall,
+};

@@ -11,6 +11,15 @@ pub const Mode = enum {
     translate,
 };
 
+// TODO merge with Type.Fn.CallingConvention
+pub const CallingConvention = enum {
+    auto,
+    c,
+    cold,
+    naked,
+    stdcall,
+};
+
 pub const ClangErrMsg = Stage2ErrorMsg;
 
 pub const Error = error{
@@ -165,9 +174,95 @@ fn transQualType(c: *Context, qt: ZigClangQualType, source_loc: ZigClangSourceLo
 }
 
 fn transType(c: *Context, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) !*ast.Node {
-    const type_name = c.str(ZigClangType_getTypeClassName(ty));
-    try emitWarning(c, source_loc, "unsupported type: '{}'", type_name);
-    return error.UnsupportedType;
+    switch (ZigClangType_getTypeClass(ty)) {
+        .Builtin => {
+            const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
+            switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+                else => {
+                    try emitWarning(c, source_loc, "unsupported builtin type");
+                    return error.UnsupportedType;
+                },
+            }
+        },
+        .FunctionProto => {
+            const fn_ty = @ptrCast(*const ZigClangFunctionType, ty);
+            const cc = switch (ZigClangFunctionType_getCallConv(fn_ty)) {
+                .C => CallingConvention.c,
+                .X86StdCall => CallingConvention.stdcall,
+                .X86FastCall => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: x86 fastcall");
+                    return error.UnsupportedType;
+                },
+                .X86ThisCall => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: x86 thiscall");
+                    return error.UnsupportedType;
+                },
+                .X86VectorCall => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: x86 vectorcall");
+                    return error.UnsupportedType;
+                },
+                .X86Pascal => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: x86 pascal");
+                    return error.UnsupportedType;
+                },
+                .Win64 => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: win64");
+                    return error.UnsupportedType;
+                },
+                .X86_64SysV => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: x86 64sysv");
+                    return error.UnsupportedType;
+                },
+                .X86RegCall => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: x86 reg");
+                    return error.UnsupportedType;
+                },
+                .AAPCS => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: aapcs");
+                    return error.UnsupportedType;
+                },
+                .AAPCS_VFP => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: aapcs-vfp");
+                    return error.UnsupportedType;
+                },
+                .IntelOclBicc => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: intel_ocl_bicc");
+                    return error.UnsupportedType;
+                },
+                .SpirFunction => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: SPIR function");
+                    return error.UnsupportedType;
+                },
+                .OpenCLKernel => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: OpenCLKernel");
+                    return error.UnsupportedType;
+                },
+                .Swift => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: Swift");
+                    return error.UnsupportedType;
+                },
+                .PreserveMost => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: PreserveMost");
+                    return error.UnsupportedType;
+                },
+                .PreserveAll => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: PreserveAll");
+                    return error.UnsupportedType;
+                },
+                .AArch64VectorCall => {
+                    try emitWarning(c, source_loc, "unsupported calling convention: AArch64VectorCall");
+                    return error.UnsupportedType;
+                },
+            };
+            try emitWarning(c, source_loc, "TODO: implement transType for FunctionProto");
+            return error.UnsupportedType;
+        },
+        else => {
+            const type_name = c.str(ZigClangType_getTypeClassName(ty));
+            try emitWarning(c, source_loc, "unsupported type: '{}'", type_name);
+            return error.UnsupportedType;
+        },
+    }
 }
 
 fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: ...) !void {

Commit eea2de108d

Commit `eea2de108d`