fixups

doc/langref.html.in

@@ -6801,6 +6801,19 @@ test "@hasDecl" {
     assert(!@hasDecl(Foo, "nope1234"));
 }
       {#code_end#}
+      {#see_also|@hasField#}
+      {#header_close#}
+
+      {#header_open|@hasField#}
+      <pre>{#syntax#}@hasField(comptime T: type, comptime name: []const u8) bool{#endsyntax#}</pre>
+      <p>Returns whether the field name of a struct, union, or enum exists.</p>
+      <p>
+      The result is a compile time constant.
+      </p>
+      <p>
+      It does not include functions, variables, or constants.
+      </p>
+      {#see_also|@hasDecl#}
       {#header_close#}
 
       {#header_open|@import#}
@@ -6940,16 +6953,6 @@ fn add(a: i32, b: i32) i32 { return a + b; }
       It does not include functions, variables, or constants.
       </p>
       {#header_close#}
-      {#header_open|@hasField#}
-      <pre>{#syntax#}@hasField(comptime T: type, comptime name: []const u8) bool{#endsyntax#}</pre>
-      <p>Returns if the field name of a struct, union, or enum exists.</p>
-      <p>
-      The result is a compile time constant.
-      </p>
-      <p>
-      It does not include functions, variables, constants.
-      </p>
-      {#header_close#}
       {#header_open|@memberType#}
       <pre>{#syntax#}@memberType(comptime T: type, comptime index: usize) type{#endsyntax#}</pre>
       <p>Returns the field type of a struct or union.</p>

src/all_types.hpp

@@ -3339,8 +3339,7 @@ struct IrInstructionHasField {
     IrInstruction base;
 
     IrInstruction *container_type;
-    Buf *field_name_buffer;
-    IrInstruction *field_name_expr;
+    IrInstruction *field_name;
 };
 
 struct IrInstructionTypeId {

src/ir.cpp

@@ -1380,15 +1380,14 @@ static IrInstruction *ir_build_field_ptr(IrBuilder *irb, Scope *scope, AstNode *
 }
 
 static IrInstruction *ir_build_has_field(IrBuilder *irb, Scope *scope, AstNode *source_node,
-    IrInstruction *container_type, IrInstruction *field_name_expr)
+    IrInstruction *container_type, IrInstruction *field_name)
 {
     IrInstructionHasField *instruction = ir_build_instruction<IrInstructionHasField>(irb, scope, source_node);
     instruction->container_type = container_type;
-    instruction->field_name_buffer = nullptr;
-    instruction->field_name_expr = field_name_expr;
+    instruction->field_name = field_name;
 
     ir_ref_instruction(container_type, irb->current_basic_block);
-    ir_ref_instruction(field_name_expr, irb->current_basic_block);
+    ir_ref_instruction(field_name, irb->current_basic_block);
 
     return &instruction->base;
 }
@@ -5132,7 +5131,7 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
                     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);
+                return ir_lval_wrap(irb, scope, type_info, lval, result_loc);
             }
         case BuiltinFnIdTypeInfo:
             {
@@ -22655,36 +22654,30 @@ 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);
+    ZigType *container_type = ir_resolve_type(ira, instruction->container_type->child);
     if (type_is_invalid(container_type))
         return ira->codegen->invalid_instruction;
 
-    if ((err = ensure_complete_type(ira->codegen, container_type)))
+    if ((err = type_resolve(ira->codegen, container_type, ResolveStatusZeroBitsKnown)))
         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;
-    }
+    Buf *field_name = ir_resolve_str(ira, instruction->field_name->child);
+    if (field_name == nullptr)
+        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)));
+    if (container_type->id == ZigTypeIdStruct) {
+        result = find_struct_type_field(container_type, field_name) != nullptr;
+    } else if (container_type->id == ZigTypeIdEnum) {
+        result = find_enum_type_field(container_type, field_name) != nullptr;
+    } else if (container_type->id == ZigTypeIdUnion) {
+        result = find_union_type_field(container_type, field_name) != nullptr;
+    } else {
+        ir_add_error(ira, instruction->container_type,
+            buf_sprintf("type '%s' does not support @hasField", 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);
+    return ir_const_bool(ira, &instruction->base, result);
 }
 
 static IrInstruction *ir_analyze_instruction_breakpoint(IrAnalyze *ira, IrInstructionBreakpoint *instruction) {

src/ir_print.cpp

@@ -1274,7 +1274,7 @@ 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);
+    ir_print_other_instruction(irp, instruction->field_name);
     fprintf(irp->f, ")");
 }
 

test/compile_errors.zig

@@ -2,6 +2,15 @@ const tests = @import("tests.zig");
 const builtin = @import("builtin");
 
 pub fn addCases(cases: *tests.CompileErrorContext) void {
+    cases.add(
+        "wrong type to @hasField",
+        \\export fn entry() bool {
+        \\    return @hasField(i32, "hi");
+        \\}
+    ,
+        "tmp.zig:2:22: error: type 'i32' does not support @hasField",
+    );
+
     cases.add(
         "slice passed as array init type with elems",
         \\export fn entry() void {

test/stage1/behavior/hasfield.zig

@@ -5,26 +5,33 @@ test "@hasField" {
     const struc = struct {
         a: i32,
         b: []u8,
+
+        pub const nope = 1;
     };
     expect(@hasField(struc, "a") == true);
     expect(@hasField(struc, "b") == true);
     expect(@hasField(struc, "non-existant") == false);
+    expect(@hasField(struc, "nope") == false);
 
     const unin = union {
         a: u64,
         b: []u16,
+
+        pub const nope = 1;
     };
     expect(@hasField(unin, "a") == true);
     expect(@hasField(unin, "b") == true);
     expect(@hasField(unin, "non-existant") == false);
+    expect(@hasField(unin, "nope") == false);
 
     const enm = enum {
         a,
         b,
+
+        pub const nope = 1;
     };
     expect(@hasField(enm, "a") == true);
     expect(@hasField(enm, "b") == true);
     expect(@hasField(enm, "non-existant") == false);
-
-    expect(@hasField(builtin, "os") == true);
+    expect(@hasField(enm, "nope") == false);
 }