diff --git a/doc/langref.html.in b/doc/langref.html.in
index cdf302d5c..78c272314 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -6940,6 +6940,16 @@ fn add(a: i32, b: i32) i32 { return a + b; }
It does not include functions, variables, or constants.
{#header_close#}
+ {#header_open|@hasField#}
+ {#syntax#}@hasField(comptime T: type, comptime name: []const u8) bool{#endsyntax#}
+ Returns if the field name of a struct, union, or enum exists.
+
+ The result is a compile time constant.
+
+
+ It does not include functions, variables, constants.
+
+ {#header_close#}
{#header_open|@memberType#}
{#syntax#}@memberType(comptime T: type, comptime index: usize) type{#endsyntax#}
Returns the field type of a struct or union.
diff --git a/src/all_types.hpp b/src/all_types.hpp
index 0dc86c4f5..ada08983a 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -1416,6 +1416,7 @@ enum BuiltinFnId {
BuiltinFnIdMemberName,
BuiltinFnIdField,
BuiltinFnIdTypeInfo,
+ BuiltinFnIdHasField,
BuiltinFnIdTypeof,
BuiltinFnIdAddWithOverflow,
BuiltinFnIdSubWithOverflow,
@@ -2307,6 +2308,7 @@ enum IrInstructionId {
IrInstructionIdByteOffsetOf,
IrInstructionIdBitOffsetOf,
IrInstructionIdTypeInfo,
+ IrInstructionIdHasField,
IrInstructionIdTypeId,
IrInstructionIdSetEvalBranchQuota,
IrInstructionIdPtrType,
@@ -3333,6 +3335,14 @@ struct IrInstructionTypeInfo {
IrInstruction *type_value;
};
+struct IrInstructionHasField {
+ IrInstruction base;
+
+ IrInstruction *container_type;
+ Buf *field_name_buffer;
+ IrInstruction *field_name_expr;
+};
+
struct IrInstructionTypeId {
IrInstruction base;
diff --git a/src/codegen.cpp b/src/codegen.cpp
index ce7cc4d4f..da9a42c65 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -5592,6 +5592,7 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
case IrInstructionIdByteOffsetOf:
case IrInstructionIdBitOffsetOf:
case IrInstructionIdTypeInfo:
+ case IrInstructionIdHasField:
case IrInstructionIdTypeId:
case IrInstructionIdSetEvalBranchQuota:
case IrInstructionIdPtrType:
@@ -7328,6 +7329,7 @@ static void define_builtin_fns(CodeGen *g) {
create_builtin_fn(g, BuiltinFnIdMemberName, "memberName", 2);
create_builtin_fn(g, BuiltinFnIdField, "field", 2);
create_builtin_fn(g, BuiltinFnIdTypeInfo, "typeInfo", 1);
+ create_builtin_fn(g, BuiltinFnIdHasField, "hasField", 2);
create_builtin_fn(g, BuiltinFnIdTypeof, "typeOf", 1); // TODO rename to TypeOf
create_builtin_fn(g, BuiltinFnIdAddWithOverflow, "addWithOverflow", 4);
create_builtin_fn(g, BuiltinFnIdSubWithOverflow, "subWithOverflow", 4);
diff --git a/src/ir.cpp b/src/ir.cpp
index abae52fcb..6f3ea2220 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -897,6 +897,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeInfo *) {
return IrInstructionIdTypeInfo;
}
+static constexpr IrInstructionId ir_instruction_id(IrInstructionHasField *) {
+ return IrInstructionIdHasField;
+}
+
static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeId *) {
return IrInstructionIdTypeId;
}
@@ -1375,6 +1379,20 @@ static IrInstruction *ir_build_field_ptr(IrBuilder *irb, Scope *scope, AstNode *
return &instruction->base;
}
+static IrInstruction *ir_build_has_field(IrBuilder *irb, Scope *scope, AstNode *source_node,
+ IrInstruction *container_type, IrInstruction *field_name_expr)
+{
+ IrInstructionHasField *instruction = ir_build_instruction(irb, scope, source_node);
+ instruction->container_type = container_type;
+ instruction->field_name_buffer = nullptr;
+ instruction->field_name_expr = field_name_expr;
+
+ ir_ref_instruction(container_type, irb->current_basic_block);
+ ir_ref_instruction(field_name_expr, irb->current_basic_block);
+
+ return &instruction->base;
+}
+
static IrInstruction *ir_build_struct_field_ptr(IrBuilder *irb, Scope *scope, AstNode *source_node,
IrInstruction *struct_ptr, TypeStructField *field)
{
@@ -5101,6 +5119,21 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
IrInstruction *load_ptr = ir_build_load_ptr(irb, scope, node, ptr_instruction);
return ir_expr_wrap(irb, scope, load_ptr, result_loc);
}
+ case BuiltinFnIdHasField:
+ {
+ AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+ IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
+ if (arg0_value == irb->codegen->invalid_instruction)
+ return arg0_value;
+
+ AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
+ IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
+ if (arg1_value == irb->codegen->invalid_instruction)
+ return arg1_value;
+
+ IrInstruction *type_info = ir_build_has_field(irb, scope, node, arg0_value, arg1_value);
+ return ir_lval_wrap(irb, scope, type_info, lval);
+ }
case BuiltinFnIdTypeInfo:
{
AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
@@ -22620,6 +22653,40 @@ static IrInstruction *ir_analyze_instruction_member_name(IrAnalyze *ira, IrInstr
}
}
+static IrInstruction *ir_analyze_instruction_has_field(IrAnalyze *ira, IrInstructionHasField *instruction) {
+ Error err;
+ IrInstruction *container_type_value = instruction->container_type->child;
+ ZigType *container_type = ir_resolve_type(ira, container_type_value);
+ if (type_is_invalid(container_type))
+ return ira->codegen->invalid_instruction;
+
+ if ((err = ensure_complete_type(ira->codegen, container_type)))
+ return ira->codegen->invalid_instruction;
+
+ Buf *field_name = instruction->field_name_buffer;
+ if (!field_name) {
+ IrInstruction *field_name_expr = instruction->field_name_expr->child;
+ field_name = ir_resolve_str(ira, field_name_expr);
+ if (!field_name)
+ return ira->codegen->invalid_instruction;
+ }
+
+ bool result;
+ if (container_type->id == ZigTypeIdStruct)
+ result = (bool)find_struct_type_field(container_type, field_name);
+ else if (container_type->id == ZigTypeIdEnum)
+ result = (bool)find_enum_type_field(container_type, field_name);
+ else if (container_type->id == ZigTypeIdUnion)
+ result = (bool)find_union_type_field(container_type, field_name);
+ else {
+ ir_add_error(ira, container_type_value,
+ buf_sprintf("type '%s' does not support @memberName", buf_ptr(&container_type->name)));
+ return ira->codegen->invalid_instruction;
+ }
+ return ir_build_const_bool(&ira->new_irb,
+ instruction->base.scope, instruction->base.source_node, result);
+}
+
static IrInstruction *ir_analyze_instruction_breakpoint(IrAnalyze *ira, IrInstructionBreakpoint *instruction) {
IrInstruction *result = ir_build_breakpoint(&ira->new_irb,
instruction->base.scope, instruction->base.source_node);
@@ -25480,6 +25547,8 @@ static IrInstruction *ir_analyze_instruction_base(IrAnalyze *ira, IrInstruction
return ir_analyze_instruction_bit_offset_of(ira, (IrInstructionBitOffsetOf *)instruction);
case IrInstructionIdTypeInfo:
return ir_analyze_instruction_type_info(ira, (IrInstructionTypeInfo *) instruction);
+ case IrInstructionIdHasField:
+ return ir_analyze_instruction_has_field(ira, (IrInstructionHasField *) instruction);
case IrInstructionIdTypeId:
return ir_analyze_instruction_type_id(ira, (IrInstructionTypeId *)instruction);
case IrInstructionIdSetEvalBranchQuota:
@@ -25788,6 +25857,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
case IrInstructionIdByteOffsetOf:
case IrInstructionIdBitOffsetOf:
case IrInstructionIdTypeInfo:
+ case IrInstructionIdHasField:
case IrInstructionIdTypeId:
case IrInstructionIdAlignCast:
case IrInstructionIdImplicitCast:
diff --git a/src/ir_print.cpp b/src/ir_print.cpp
index a97307990..3b6ee3273 100644
--- a/src/ir_print.cpp
+++ b/src/ir_print.cpp
@@ -1270,6 +1270,14 @@ static void ir_print_type_info(IrPrint *irp, IrInstructionTypeInfo *instruction)
fprintf(irp->f, ")");
}
+static void ir_print_has_field(IrPrint *irp, IrInstructionHasField *instruction) {
+ fprintf(irp->f, "@hasField(");
+ ir_print_other_instruction(irp, instruction->container_type);
+ fprintf(irp->f, ",");
+ ir_print_other_instruction(irp, instruction->field_name_expr);
+ fprintf(irp->f, ")");
+}
+
static void ir_print_type_id(IrPrint *irp, IrInstructionTypeId *instruction) {
fprintf(irp->f, "@typeId(");
ir_print_other_instruction(irp, instruction->type_value);
@@ -1965,6 +1973,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
case IrInstructionIdTypeInfo:
ir_print_type_info(irp, (IrInstructionTypeInfo *)instruction);
break;
+ case IrInstructionIdHasField:
+ ir_print_has_field(irp, (IrInstructionHasField *)instruction);
+ break;
case IrInstructionIdTypeId:
ir_print_type_id(irp, (IrInstructionTypeId *)instruction);
break;
diff --git a/test/stage1/behavior.zig b/test/stage1/behavior.zig
index 5cb04966e..db8fdcf36 100644
--- a/test/stage1/behavior.zig
+++ b/test/stage1/behavior.zig
@@ -98,4 +98,5 @@ comptime {
_ = @import("behavior/void.zig");
_ = @import("behavior/while.zig");
_ = @import("behavior/widening.zig");
+ _ = @import("behavior/hasfield.zig");
}
diff --git a/test/stage1/behavior/hasfield.zig b/test/stage1/behavior/hasfield.zig
new file mode 100644
index 000000000..0e18cb19b
--- /dev/null
+++ b/test/stage1/behavior/hasfield.zig
@@ -0,0 +1,30 @@
+const expect = @import("std").testing.expect;
+const builtin = @import("builtin");
+
+test "@hasField" {
+ const struc = struct {
+ a: i32,
+ b: []u8,
+ };
+ expect(@hasField(struc, "a") == true);
+ expect(@hasField(struc, "b") == true);
+ expect(@hasField(struc, "non-existant") == false);
+
+ const unin = union {
+ a: u64,
+ b: []u16,
+ };
+ expect(@hasField(unin, "a") == true);
+ expect(@hasField(unin, "b") == true);
+ expect(@hasField(unin, "non-existant") == false);
+
+ const enm = enum {
+ a,
+ b,
+ };
+ expect(@hasField(enm, "a") == true);
+ expect(@hasField(enm, "b") == true);
+ expect(@hasField(enm, "non-existant") == false);
+
+ expect(@hasField(builtin, "os") == true);
+}