From c19bdc2d370f3a72ef492e2f4e6264e2a0dd91ec Mon Sep 17 00:00:00 2001 From: Shawn Landden Date: Mon, 6 May 2019 11:41:15 -0500 Subject: [PATCH 1/3] stage1: add @hasField() built-in This was quite straight-forward Closes: #1439 --- src/all_types.hpp | 10 ++++++ src/codegen.cpp | 2 ++ src/ir.cpp | 70 ++++++++++++++++++++++++++++++++++++++++ src/ir_print.cpp | 11 +++++++ test/stage1/behavior.zig | 1 + 5 files changed, 94 insertions(+) diff --git a/src/all_types.hpp b/src/all_types.hpp index 5a5c1cfda40c..80a48db03afa 100644 --- a/src/all_types.hpp +++ b/src/all_types.hpp @@ -1394,6 +1394,7 @@ enum BuiltinFnId { BuiltinFnIdMemberName, BuiltinFnIdField, BuiltinFnIdTypeInfo, + BuiltinFnIdHasField, BuiltinFnIdTypeof, BuiltinFnIdAddWithOverflow, BuiltinFnIdSubWithOverflow, @@ -2251,6 +2252,7 @@ enum IrInstructionId { IrInstructionIdByteOffsetOf, IrInstructionIdBitOffsetOf, IrInstructionIdTypeInfo, + IrInstructionIdHasField, IrInstructionIdTypeId, IrInstructionIdSetEvalBranchQuota, IrInstructionIdPtrType, @@ -3229,6 +3231,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 7dfdf717253f..1253a6a6af97 100644 --- a/src/codegen.cpp +++ b/src/codegen.cpp @@ -5530,6 +5530,7 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable, case IrInstructionIdByteOffsetOf: case IrInstructionIdBitOffsetOf: case IrInstructionIdTypeInfo: + case IrInstructionIdHasField: case IrInstructionIdTypeId: case IrInstructionIdSetEvalBranchQuota: case IrInstructionIdPtrType: @@ -7271,6 +7272,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 91f931462e54..fdd7291de37f 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -851,6 +851,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; } @@ -1280,6 +1284,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) { @@ -4598,6 +4616,21 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo return ir_build_load_ptr(irb, scope, node, ptr_instruction); } + 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); @@ -20578,6 +20611,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); @@ -23068,6 +23135,8 @@ static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructio 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: @@ -23355,6 +23424,7 @@ bool ir_has_side_effects(IrInstruction *instruction) { case IrInstructionIdByteOffsetOf: case IrInstructionIdBitOffsetOf: case IrInstructionIdTypeInfo: + case IrInstructionIdHasField: case IrInstructionIdTypeId: case IrInstructionIdAlignCast: case IrInstructionIdOpaqueType: diff --git a/src/ir_print.cpp b/src/ir_print.cpp index dba0e4ee00b8..683bf0dd86d0 100644 --- a/src/ir_print.cpp +++ b/src/ir_print.cpp @@ -1107,6 +1107,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); @@ -1757,6 +1765,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 bc3be172ab3e..9334f95de60c 100644 --- a/test/stage1/behavior.zig +++ b/test/stage1/behavior.zig @@ -94,4 +94,5 @@ comptime { _ = @import("behavior/void.zig"); _ = @import("behavior/while.zig"); _ = @import("behavior/widening.zig"); + _ = @import("behavior/hasfield.zig"); } From d1f9b8184d61674a77424f026adfef2752d1dfdd Mon Sep 17 00:00:00 2001 From: Shawn Landden Date: Mon, 6 May 2019 11:56:51 -0500 Subject: [PATCH 2/3] docs for @hasField --- doc/langref.html.in | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/doc/langref.html.in b/doc/langref.html.in index d11204f61979..02375639fbc3 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -6867,6 +6867,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: []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.

From 5a91dbc16cbe20a95aafb6b3221c4a5a07d9b117 Mon Sep 17 00:00:00 2001 From: Shawn Landden Date: Mon, 27 May 2019 00:35:35 -0500 Subject: [PATCH 3/3] allow const to be passed to @hasField() Actually include the tests I wrote --- doc/langref.html.in | 2 +- test/stage1/behavior/hasfield.zig | 30 ++++++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 test/stage1/behavior/hasfield.zig diff --git a/doc/langref.html.in b/doc/langref.html.in index 02375639fbc3..3bb38c043782 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -6868,7 +6868,7 @@ fn add(a: i32, b: i32) i32 { return a + b; }

{#header_close#} {#header_open|@hasField#} - 
{#syntax#}@hasField(comptime T: type, comptime name: []u8) bool{#endsyntax#}
+ 
{#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. diff --git a/test/stage1/behavior/hasfield.zig b/test/stage1/behavior/hasfield.zig new file mode 100644 index 000000000000..0e18cb19b56b --- /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); +}