Commit d9ed55f017bdd23054cd1d7f50ac1da517b5a5e4 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-08-27 12:54:50-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-08-27 12:54:50-04:00
log	d9ed55f017bdd23054cd1d7f50ac1da517b5a5e4
tree	6c4373b33345846a4ee9e467e430830b8b42c0a5
parent	7d34e55a71b1d929c6e847337a3639f3e65a547e
signature	Commit is signed but in an unrecognized format.

fix not properly casting align values

and add check for alignment specified on enum fields

4 files changed, 137 insertions(+), 108 deletions(-)

src
test
- compile_errors.zig

src/all_types.hpp+23-20

...	@@ -315,58 +315,61 @@ enum LazyValueId {	...	@@ -315,58 +315,61 @@ enum LazyValueId {
315	};	315	};
316		316
317	struct LazyValue {	317	struct LazyValue {
318	IrExecutable *exec;
319	LazyValueId id;	318	LazyValueId id;
320	};	319	};
321		320
322	struct LazyValueAlignOf {	321	struct LazyValueAlignOf {
323	LazyValue base;	322	LazyValue base;
324		323
325	ConstExprValue *target_type_val;	324	IrAnalyze *ira;
326	AstNode *target_type_src_node;	325	IrInstruction *target_type;
327	};	326	};
328		327
329	struct LazyValueSliceType {	328	struct LazyValueSliceType {
330	LazyValue base;	329	LazyValue base;
		330
		331	IrAnalyze *ira;
		332	ZigType *elem_type;
		333	IrInstruction *align_inst; // can be null
		334
331	bool is_const;	335	bool is_const;
332	bool is_volatile;	336	bool is_volatile;
333	bool is_allowzero;	337	bool is_allowzero;
334
335	ZigType *elem_type;
336	ConstExprValue *align_val; // can be null
337	};	338	};
338		339
339	struct LazyValuePtrType {	340	struct LazyValuePtrType {
340	LazyValue base;	341	LazyValue base;
341	bool is_const;
342	bool is_volatile;
343	bool is_allowzero;
344		342
345	ConstExprValue *elem_type_val;	343	IrAnalyze *ira;
346	AstNode *elem_type_src_node;	344	IrInstruction *elem_type;
347	ConstExprValue *align_val; // can be null	345	IrInstruction *align_inst; // can be null
		346
348	PtrLen ptr_len;	347	PtrLen ptr_len;
349	uint32_t bit_offset_in_host;	348	uint32_t bit_offset_in_host;
		349
350	uint32_t host_int_bytes;	350	uint32_t host_int_bytes;
		351	bool is_const;
		352	bool is_volatile;
		353	bool is_allowzero;
351	};	354	};
352		355
353	struct LazyValueOptType {	356	struct LazyValueOptType {
354	LazyValue base;	357	LazyValue base;
355		358
356	ConstExprValue *payload_type_val;	359	IrAnalyze *ira;
357	AstNode *payload_type_src_node;	360	IrInstruction *payload_type;
358	};	361	};
359		362
360	struct LazyValueFnType {	363	struct LazyValueFnType {
361	LazyValue base;	364	LazyValue base;
362	bool is_generic;
363		365
		366	IrAnalyze *ira;
364	AstNode *proto_node;	367	AstNode *proto_node;
365	ConstExprValue **param_types;	368	IrInstruction **param_types;
366	AstNode **param_type_src_nodes;	369	IrInstruction *align_inst; // can be null
367	ConstExprValue *align_val; // can be null	370	IrInstruction *return_type;
368	ConstExprValue *return_type;	371
369	AstNode *return_type_src_node;	372	bool is_generic;
370	};	373	};
371		374
372	struct ConstExprValue {	375	struct ConstExprValue {

src/analyze.cpp+12-7

 @@ -1000,7 +1000,7 @@ static Error type_val_resolve_zero_bits(CodeGen *g, ConstExprValue *type_val, Zi
         case LazyValueIdPtrType: {
             LazyValuePtrType *lazy_ptr_type = reinterpret_cast<LazyValuePtrType *>(type_val->data.x_lazy);
-            if (parent_type_val == lazy_ptr_type->elem_type_val) {
+            if (parent_type_val == &lazy_ptr_type->elem_type->value) {
                 // Does a struct which contains a pointer field to itself have bits? Yes.
                 *is_zero_bits = false;
                 return ErrorNone;
 @@ -1008,7 +1008,7 @@ static Error type_val_resolve_zero_bits(CodeGen *g, ConstExprValue *type_val, Zi
                 if (parent_type_val == nullptr) {
                     parent_type_val = type_val;
                 }
-                return type_val_resolve_zero_bits(g, lazy_ptr_type->elem_type_val, parent_type,
+                return type_val_resolve_zero_bits(g, &lazy_ptr_type->elem_type->value, parent_type,
                         parent_type_val, is_zero_bits);
             }
         }
 @@ -1061,17 +1061,17 @@ static ReqCompTime type_val_resolve_requires_comptime(CodeGen *g, ConstExprValue
         }
         case LazyValueIdPtrType: {
             LazyValuePtrType *lazy_ptr_type = reinterpret_cast<LazyValuePtrType *>(type_val->data.x_lazy);
-            return type_val_resolve_requires_comptime(g, lazy_ptr_type->elem_type_val);
+            return type_val_resolve_requires_comptime(g, &lazy_ptr_type->elem_type->value);
         }
         case LazyValueIdOptType: {
             LazyValueOptType *lazy_opt_type = reinterpret_cast<LazyValueOptType *>(type_val->data.x_lazy);
-            return type_val_resolve_requires_comptime(g, lazy_opt_type->payload_type_val);
+            return type_val_resolve_requires_comptime(g, &lazy_opt_type->payload_type->value);
         }
         case LazyValueIdFnType: {
             LazyValueFnType *lazy_fn_type = reinterpret_cast<LazyValueFnType *>(type_val->data.x_lazy);
             if (lazy_fn_type->is_generic)
                 return ReqCompTimeYes;
-            switch (type_val_resolve_requires_comptime(g, lazy_fn_type->return_type)) {
+            switch (type_val_resolve_requires_comptime(g, &lazy_fn_type->return_type->value)) {
                 case ReqCompTimeInvalid:
                     return ReqCompTimeInvalid;
                 case ReqCompTimeYes:
 @@ -1084,7 +1084,7 @@ static ReqCompTime type_val_resolve_requires_comptime(CodeGen *g, ConstExprValue
                 AstNode *param_node = lazy_fn_type->proto_node->data.fn_proto.params.at(i);
                 bool param_is_var_args = param_node->data.param_decl.is_var_args;
                 if (param_is_var_args) break;
-                switch (type_val_resolve_requires_comptime(g, lazy_fn_type->param_types[i])) {
+                switch (type_val_resolve_requires_comptime(g, &lazy_fn_type->param_types[i]->value)) {
                     case ReqCompTimeInvalid:
                         return ReqCompTimeInvalid;
                     case ReqCompTimeYes:
 @@ -1124,7 +1124,7 @@ Error type_val_resolve_abi_align(CodeGen *g, ConstExprValue *type_val, uint32_t
             return ErrorNone;
         case LazyValueIdOptType: {
             LazyValueOptType *lazy_opt_type = reinterpret_cast<LazyValueOptType *>(type_val->data.x_lazy);
-            return type_val_resolve_abi_align(g, lazy_opt_type->payload_type_val, abi_align);
+            return type_val_resolve_abi_align(g, &lazy_opt_type->payload_type->value, abi_align);
         }
     }
     zig_unreachable();
 @@ -2245,6 +2245,11 @@ static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
                 buf_sprintf("structs and unions, not enums, support field types"));
             add_error_note(g, msg, decl_node,
                     buf_sprintf("consider 'union(enum)' here"));
+        } else if (field_node->data.struct_field.align_expr != nullptr) {
+            ErrorMsg *msg = add_node_error(g, field_node->data.struct_field.align_expr,
+                buf_sprintf("structs and unions, not enums, support field alignment"));
+            add_error_note(g, msg, decl_node,
+                    buf_sprintf("consider 'union(enum)' here"));
         }
         auto field_entry = enum_type->data.enumeration.fields_by_name.put_unique(type_enum_field->name, type_enum_field);

src/ir.cpp+75-81

 @@ -16190,14 +16190,13 @@ static IrInstruction *ir_analyze_optional_type(IrAnalyze *ira, IrInstructionUnOp
     result->value.special = ConstValSpecialLazy;
     LazyValueOptType *lazy_opt_type = allocate<LazyValueOptType>(1);
+    lazy_opt_type->ira = ira;
     result->value.data.x_lazy = &lazy_opt_type->base;
     lazy_opt_type->base.id = LazyValueIdOptType;
-    lazy_opt_type->base.exec = ira->new_irb.exec;
-    lazy_opt_type->payload_type_val = ir_resolve_type_lazy(ira, instruction->value->child);
+    lazy_opt_type->payload_type = instruction->value->child;
-    if (lazy_opt_type->payload_type_val == nullptr)
+    if (ir_resolve_type_lazy(ira, lazy_opt_type->payload_type) == nullptr)
         return ira->codegen->invalid_instruction;
-    lazy_opt_type->payload_type_src_node = instruction->value->source_node;
     return result;
 }
 @@ -17936,13 +17935,13 @@ static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira,
     result->value.special = ConstValSpecialLazy;
     LazyValueSliceType *lazy_slice_type = allocate<LazyValueSliceType>(1);
+    lazy_slice_type->ira = ira;
     result->value.data.x_lazy = &lazy_slice_type->base;
     lazy_slice_type->base.id = LazyValueIdSliceType;
-    lazy_slice_type->base.exec = ira->new_irb.exec;
     if (slice_type_instruction->align_value != nullptr) {
-        lazy_slice_type->align_val = ir_resolve_const(ira, slice_type_instruction->align_value->child, LazyOk);
+        lazy_slice_type->align_inst = slice_type_instruction->align_value->child;
-        if (lazy_slice_type->align_val == nullptr)
+        if (ir_resolve_const(ira, lazy_slice_type->align_inst, LazyOk) == nullptr)
             return ira->codegen->invalid_instruction;
     }
 @@ -22371,14 +22370,13 @@ static IrInstruction *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstruct
     result->value.special = ConstValSpecialLazy;
     LazyValueAlignOf *lazy_align_of = allocate<LazyValueAlignOf>(1);
+    lazy_align_of->ira = ira;
     result->value.data.x_lazy = &lazy_align_of->base;
     lazy_align_of->base.id = LazyValueIdAlignOf;
-    lazy_align_of->base.exec = ira->new_irb.exec;
-    lazy_align_of->target_type_val = ir_resolve_type_lazy(ira, instruction->type_value->child);
+    lazy_align_of->target_type = instruction->type_value->child;
-    if (lazy_align_of->target_type_val == nullptr)
+    if (ir_resolve_type_lazy(ira, lazy_align_of->target_type) == nullptr)
         return ira->codegen->invalid_instruction;
-    lazy_align_of->target_type_src_node = instruction->type_value->source_node;
     return result;
 }
 @@ -22856,9 +22854,9 @@ static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstruct
     result->value.special = ConstValSpecialLazy;
     LazyValueFnType *lazy_fn_type = allocate<LazyValueFnType>(1);
+    lazy_fn_type->ira = ira;
     result->value.data.x_lazy = &lazy_fn_type->base;
     lazy_fn_type->base.id = LazyValueIdFnType;
-    lazy_fn_type->base.exec = ira->new_irb.exec;
     if (proto_node->data.fn_proto.auto_err_set) {
         ir_add_error(ira, &instruction->base,
 @@ -22868,8 +22866,7 @@ static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstruct
     size_t param_count = proto_node->data.fn_proto.params.length;
     lazy_fn_type->proto_node = proto_node;
-    lazy_fn_type->param_types = allocate<ConstExprValue *>(param_count);
+    lazy_fn_type->param_types = allocate<IrInstruction *>(param_count);
-    lazy_fn_type->param_type_src_nodes = allocate<AstNode *>(param_count);
     for (size_t param_index = 0; param_index < param_count; param_index += 1) {
         AstNode *param_node = proto_node->data.fn_proto.params.at(param_index);
 @@ -22895,23 +22892,20 @@ static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstruct
         IrInstruction *param_type_value = instruction->param_types[param_index]->child;
         if (type_is_invalid(param_type_value->value.type))
             return ira->codegen->invalid_instruction;
-        ConstExprValue *param_type_val = ir_resolve_const(ira, param_type_value, LazyOk);
+        if (ir_resolve_const(ira, param_type_value, LazyOk) == nullptr)
-        if (param_type_val == nullptr)
             return ira->codegen->invalid_instruction;
-        lazy_fn_type->param_types[param_index] = param_type_val;
+        lazy_fn_type->param_types[param_index] = param_type_value;
-        lazy_fn_type->param_type_src_nodes[param_index] = instruction->param_types[param_index]->source_node;
     }
     if (instruction->align_value != nullptr) {
-        lazy_fn_type->align_val = ir_resolve_const(ira, instruction->align_value->child, LazyOk);
+        lazy_fn_type->align_inst = instruction->align_value->child;
-        if (lazy_fn_type->align_val == nullptr)
+        if (ir_resolve_const(ira, lazy_fn_type->align_inst, LazyOk) == nullptr)
             return ira->codegen->invalid_instruction;
     }
-    lazy_fn_type->return_type = ir_resolve_const(ira, instruction->return_type->child, LazyOk);
+    lazy_fn_type->return_type = instruction->return_type->child;
-    if (lazy_fn_type->return_type == nullptr)
+    if (ir_resolve_const(ira, lazy_fn_type->return_type, LazyOk) == nullptr)
          return ira->codegen->invalid_instruction;
-    lazy_fn_type->return_type_src_node = instruction->return_type->source_node;
     return result;
 }
 @@ -23890,18 +23884,17 @@ static IrInstruction *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstruct
     result->value.special = ConstValSpecialLazy;
     LazyValuePtrType *lazy_ptr_type = allocate<LazyValuePtrType>(1);
+    lazy_ptr_type->ira = ira;
     result->value.data.x_lazy = &lazy_ptr_type->base;
     lazy_ptr_type->base.id = LazyValueIdPtrType;
-    lazy_ptr_type->base.exec = ira->new_irb.exec;
-    lazy_ptr_type->elem_type_val = ir_resolve_type_lazy(ira, instruction->child_type->child);
+    lazy_ptr_type->elem_type = instruction->child_type->child;
-    if (lazy_ptr_type->elem_type_val == nullptr)
+    if (ir_resolve_type_lazy(ira, lazy_ptr_type->elem_type) == nullptr)
         return ira->codegen->invalid_instruction;
-    lazy_ptr_type->elem_type_src_node = instruction->child_type->source_node;
     if (instruction->align_value != nullptr) {
-        lazy_ptr_type->align_val = ir_resolve_const(ira, instruction->align_value->child, LazyOk);
+        lazy_ptr_type->align_inst = instruction->align_value->child;
-        if (lazy_ptr_type->align_val == nullptr)
+        if (ir_resolve_const(ira, lazy_ptr_type->align_inst, LazyOk) == nullptr)
             return ira->codegen->invalid_instruction;
     }
 @@ -25446,9 +25439,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
     zig_unreachable();
 }
-static ZigType *ir_resolve_lazy_fn_type(CodeGen *codegen, IrExecutable *exec, AstNode *source_node,
+static ZigType *ir_resolve_lazy_fn_type(IrAnalyze *ira, AstNode *source_node, LazyValueFnType *lazy_fn_type) {
-        LazyValueFnType *lazy_fn_type)
-{
     Error err;
     AstNode *proto_node = lazy_fn_type->proto_node;
 @@ -25465,7 +25456,7 @@ static ZigType *ir_resolve_lazy_fn_type(CodeGen *codegen, IrExecutable *exec, As
                 fn_type_id.param_count = fn_type_id.next_param_index;
                 continue;
             } else if (fn_type_id.cc == CallingConventionUnspecified) {
-                return get_generic_fn_type(codegen, &fn_type_id);
+                return get_generic_fn_type(ira->codegen, &fn_type_id);
             } else {
                 zig_unreachable();
             }
 @@ -25475,34 +25466,33 @@ static ZigType *ir_resolve_lazy_fn_type(CodeGen *codegen, IrExecutable *exec, As
         if (lazy_fn_type->param_types[fn_type_id.next_param_index] == nullptr) {
             param_info->type = nullptr;
-            return get_generic_fn_type(codegen, &fn_type_id);
+            return get_generic_fn_type(ira->codegen, &fn_type_id);
         } else {
-            AstNode *param_src_node = lazy_fn_type->param_type_src_nodes[fn_type_id.next_param_index];
+            IrInstruction *param_type_inst = lazy_fn_type->param_types[fn_type_id.next_param_index];
-            ZigType *param_type = ir_resolve_const_type(codegen, exec, param_src_node,
+            ZigType *param_type = ir_resolve_type(ira, param_type_inst);
-                    lazy_fn_type->param_types[fn_type_id.next_param_index]);
             if (type_is_invalid(param_type))
                 return nullptr;
-            switch (type_requires_comptime(codegen, param_type)) {
+            switch (type_requires_comptime(ira->codegen, param_type)) {
             case ReqCompTimeYes:
                 if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
-                    exec_add_error_node(codegen, exec, param_src_node,
+                    ir_add_error(ira, param_type_inst,
                         buf_sprintf("parameter of type '%s' not allowed in function with calling convention '%s'",
                             buf_ptr(&param_type->name), calling_convention_name(fn_type_id.cc)));
                     return nullptr;
                 }
                 param_info->type = param_type;
                 fn_type_id.next_param_index += 1;
-                return get_generic_fn_type(codegen, &fn_type_id);
+                return get_generic_fn_type(ira->codegen, &fn_type_id);
             case ReqCompTimeInvalid:
                 return nullptr;
             case ReqCompTimeNo:
                 break;
             }
             if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
-                if ((err = type_resolve(codegen, param_type, ResolveStatusZeroBitsKnown)))
+                if ((err = type_resolve(ira->codegen, param_type, ResolveStatusZeroBitsKnown)))
                     return nullptr;
                 if (!type_has_bits(param_type)) {
-                    exec_add_error_node(codegen, exec, param_src_node,
+                    ir_add_error(ira, param_type_inst,
                         buf_sprintf("parameter of type '%s' has 0 bits; not allowed in function with calling convention '%s'",
                             buf_ptr(&param_type->name), calling_convention_name(fn_type_id.cc)));
                     return nullptr;
 @@ -25512,37 +25502,35 @@ static ZigType *ir_resolve_lazy_fn_type(CodeGen *codegen, IrExecutable *exec, As
         }
     }
-    if (lazy_fn_type->align_val != nullptr) {
+    if (lazy_fn_type->align_inst != nullptr) {
-        if (!ir_resolve_const_align(codegen, exec, source_node, lazy_fn_type->align_val, &fn_type_id.alignment))
+        if (!ir_resolve_align(ira, lazy_fn_type->align_inst, &fn_type_id.alignment))
             return nullptr;
     }
-    fn_type_id.return_type = ir_resolve_const_type(codegen, exec, lazy_fn_type->return_type_src_node,
+    fn_type_id.return_type = ir_resolve_type(ira, lazy_fn_type->return_type);
-            lazy_fn_type->return_type);
     if (type_is_invalid(fn_type_id.return_type))
         return nullptr;
     if (fn_type_id.return_type->id == ZigTypeIdOpaque) {
-        exec_add_error_node(codegen, exec, lazy_fn_type->return_type_src_node,
+        ir_add_error(ira, lazy_fn_type->return_type, buf_create_from_str("return type cannot be opaque"));
-            buf_create_from_str("return type cannot be opaque"));
         return nullptr;
     }
-    return get_fn_type(codegen, &fn_type_id);
+    return get_fn_type(ira->codegen, &fn_type_id);
 }
-static Error ir_resolve_lazy_raw(CodeGen *codegen, AstNode *source_node, ConstExprValue *val) {
+static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
     Error err;
     if (val->special != ConstValSpecialLazy)
         return ErrorNone;
-    IrExecutable *exec = val->data.x_lazy->exec;
     switch (val->data.x_lazy->id) {
         case LazyValueIdInvalid:
             zig_unreachable();
         case LazyValueIdAlignOf: {
             LazyValueAlignOf *lazy_align_of = reinterpret_cast<LazyValueAlignOf *>(val->data.x_lazy);
+            IrAnalyze *ira = lazy_align_of->ira;
-            if (lazy_align_of->target_type_val->special == ConstValSpecialStatic) {
+            if (lazy_align_of->target_type->value.special == ConstValSpecialStatic) {
-                switch (lazy_align_of->target_type_val->data.x_type->id) {
+                switch (lazy_align_of->target_type->value.data.x_type->id) {
                     case ZigTypeIdInvalid:
                         zig_unreachable();
                     case ZigTypeIdMetaType:
 @@ -25556,9 +25544,9 @@ static Error ir_resolve_lazy_raw(CodeGen *codegen, AstNode *source_node, ConstEx
                     case ZigTypeIdArgTuple:
                     case ZigTypeIdVoid:
                     case ZigTypeIdOpaque:
-                        exec_add_error_node(codegen, exec, lazy_align_of->target_type_src_node,
+                        ir_add_error(ira, lazy_align_of->target_type,
                             buf_sprintf("no align available for type '%s'",
-                                buf_ptr(&lazy_align_of->target_type_val->data.x_type->name)));
+                                buf_ptr(&lazy_align_of->target_type->value.data.x_type->name)));
                         return ErrorSemanticAnalyzeFail;
                     case ZigTypeIdBool:
                     case ZigTypeIdInt:
 @@ -25580,8 +25568,11 @@ static Error ir_resolve_lazy_raw(CodeGen *codegen, AstNode *source_node, ConstEx
             }
             uint32_t align_in_bytes;
-            if ((err = type_val_resolve_abi_align(codegen, lazy_align_of->target_type_val, &align_in_bytes)))
+            if ((err = type_val_resolve_abi_align(ira->codegen, &lazy_align_of->target_type->value,
+                            &align_in_bytes)))
+            {
                 return err;
+            }
             val->special = ConstValSpecialStatic;
             assert(val->type->id == ZigTypeIdComptimeInt);
 @@ -25590,69 +25581,72 @@ static Error ir_resolve_lazy_raw(CodeGen *codegen, AstNode *source_node, ConstEx
         }
         case LazyValueIdSliceType: {
             LazyValueSliceType *lazy_slice_type = reinterpret_cast<LazyValueSliceType *>(val->data.x_lazy);
+            IrAnalyze *ira = lazy_slice_type->ira;
             uint32_t align_bytes = 0;
-            if (lazy_slice_type->align_val != nullptr) {
+            if (lazy_slice_type->align_inst != nullptr) {
-                if (!ir_resolve_const_align(codegen, exec, source_node, lazy_slice_type->align_val, &align_bytes))
+                if (!ir_resolve_align(ira, lazy_slice_type->align_inst, &align_bytes))
                     return ErrorSemanticAnalyzeFail;
             }
             ResolveStatus needed_status = (align_bytes == 0) ?
                 ResolveStatusZeroBitsKnown : ResolveStatusAlignmentKnown;
-            if ((err = type_resolve(codegen, lazy_slice_type->elem_type, needed_status)))
+            if ((err = type_resolve(ira->codegen, lazy_slice_type->elem_type, needed_status)))
                 return err;
-            ZigType *slice_ptr_type = get_pointer_to_type_extra(codegen, lazy_slice_type->elem_type,
+            ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, lazy_slice_type->elem_type,
                     lazy_slice_type->is_const, lazy_slice_type->is_volatile, PtrLenUnknown, align_bytes,
                     0, 0, lazy_slice_type->is_allowzero);
             val->special = ConstValSpecialStatic;
             assert(val->type->id == ZigTypeIdMetaType);
-            val->data.x_type = get_slice_type(codegen, slice_ptr_type);
+            val->data.x_type = get_slice_type(ira->codegen, slice_ptr_type);
             return ErrorNone;
         }
         case LazyValueIdPtrType: {
             LazyValuePtrType *lazy_ptr_type = reinterpret_cast<LazyValuePtrType *>(val->data.x_lazy);
+            IrAnalyze *ira = lazy_ptr_type->ira;
             uint32_t align_bytes = 0;
-            if (lazy_ptr_type->align_val != nullptr) {
+            if (lazy_ptr_type->align_inst != nullptr) {
-                if (!ir_resolve_const_align(codegen, exec, source_node, lazy_ptr_type->align_val, &align_bytes))
+                if (!ir_resolve_align(ira, lazy_ptr_type->align_inst, &align_bytes))
                     return ErrorSemanticAnalyzeFail;
             }
-            ZigType *elem_type = ir_resolve_const_type(codegen, exec, lazy_ptr_type->elem_type_src_node,
+            ZigType *elem_type = ir_resolve_type(ira, lazy_ptr_type->elem_type);
-                    lazy_ptr_type->elem_type_val);
             if (type_is_invalid(elem_type))
                 return ErrorSemanticAnalyzeFail;
             if (elem_type->id == ZigTypeIdUnreachable) {
-                exec_add_error_node(codegen, exec, lazy_ptr_type->elem_type_src_node,
+                ir_add_error(ira, lazy_ptr_type->elem_type,
                         buf_create_from_str("pointer to noreturn not allowed"));
                 return ErrorSemanticAnalyzeFail;
             } else if (elem_type->id == ZigTypeIdOpaque && lazy_ptr_type->ptr_len == PtrLenUnknown) {
-                exec_add_error_node(codegen, exec, lazy_ptr_type->elem_type_src_node,
+                ir_add_error(ira, lazy_ptr_type->elem_type,
                         buf_create_from_str("unknown-length pointer to opaque"));
                 return ErrorSemanticAnalyzeFail;
             } else if (lazy_ptr_type->ptr_len == PtrLenC) {
-                if (!type_allowed_in_extern(codegen, elem_type)) {
+                if (!type_allowed_in_extern(ira->codegen, elem_type)) {
-                    exec_add_error_node(codegen, exec, lazy_ptr_type->elem_type_src_node,
+                    ir_add_error(ira, lazy_ptr_type->elem_type,
                         buf_sprintf("C pointers cannot point to non-C-ABI-compatible type '%s'",
                             buf_ptr(&elem_type->name)));
                     return ErrorSemanticAnalyzeFail;
                 } else if (elem_type->id == ZigTypeIdOpaque) {
-                    exec_add_error_node(codegen, exec, lazy_ptr_type->elem_type_src_node,
+                    ir_add_error(ira, lazy_ptr_type->elem_type,
                             buf_sprintf("C pointers cannot point opaque types"));
                     return ErrorSemanticAnalyzeFail;
                 } else if (lazy_ptr_type->is_allowzero) {
-                    exec_add_error_node(codegen, exec, lazy_ptr_type->elem_type_src_node,
+                    ir_add_error(ira, lazy_ptr_type->elem_type,
                             buf_sprintf("C pointers always allow address zero"));
                     return ErrorSemanticAnalyzeFail;
                 }
             }
             if (align_bytes != 0) {
-                if ((err = type_resolve(codegen, elem_type, ResolveStatusAlignmentKnown)))
+                if ((err = type_resolve(ira->codegen, elem_type, ResolveStatusAlignmentKnown)))
                     return err;
                 if (!type_has_bits(elem_type))
                     align_bytes = 0;
             }
             bool allow_zero = lazy_ptr_type->is_allowzero || lazy_ptr_type->ptr_len == PtrLenC;
             assert(val->type->id == ZigTypeIdMetaType);
-            val->data.x_type = get_pointer_to_type_extra(codegen, elem_type,
+            val->data.x_type = get_pointer_to_type_extra(ira->codegen, elem_type,
                     lazy_ptr_type->is_const, lazy_ptr_type->is_volatile, lazy_ptr_type->ptr_len, align_bytes,
                     lazy_ptr_type->bit_offset_in_host, lazy_ptr_type->host_int_bytes,
                     allow_zero);
 @@ -25661,29 +25655,29 @@ static Error ir_resolve_lazy_raw(CodeGen *codegen, AstNode *source_node, ConstEx
         }
         case LazyValueIdOptType: {
             LazyValueOptType *lazy_opt_type = reinterpret_cast<LazyValueOptType *>(val->data.x_lazy);
+            IrAnalyze *ira = lazy_opt_type->ira;
-            ZigType *payload_type = ir_resolve_const_type(codegen, exec, lazy_opt_type->payload_type_src_node,
+            ZigType *payload_type = ir_resolve_type(ira, lazy_opt_type->payload_type);
-                    lazy_opt_type->payload_type_val);
             if (type_is_invalid(payload_type))
                 return ErrorSemanticAnalyzeFail;
             if (payload_type->id == ZigTypeIdOpaque || payload_type->id == ZigTypeIdUnreachable) {
-                exec_add_error_node(codegen, exec, lazy_opt_type->payload_type_src_node,
+                ir_add_error(ira, lazy_opt_type->payload_type,
                         buf_sprintf("type '%s' cannot be optional", buf_ptr(&payload_type->name)));
                 return ErrorSemanticAnalyzeFail;
             }
-            if ((err = type_resolve(codegen, payload_type, ResolveStatusSizeKnown)))
+            if ((err = type_resolve(ira->codegen, payload_type, ResolveStatusSizeKnown)))
                 return err;
             assert(val->type->id == ZigTypeIdMetaType);
-            val->data.x_type = get_optional_type(codegen, payload_type);
+            val->data.x_type = get_optional_type(ira->codegen, payload_type);
             val->special = ConstValSpecialStatic;
             return ErrorNone;
         }
         case LazyValueIdFnType: {
-            ZigType *fn_type = ir_resolve_lazy_fn_type(codegen, exec, source_node,
+            LazyValueFnType *lazy_fn_type = reinterpret_cast<LazyValueFnType *>(val->data.x_lazy);
-                    reinterpret_cast<LazyValueFnType *>(val->data.x_lazy));
+            ZigType *fn_type = ir_resolve_lazy_fn_type(lazy_fn_type->ira, source_node, lazy_fn_type);
             if (fn_type == nullptr)
                 return ErrorSemanticAnalyzeFail;
             val->special = ConstValSpecialStatic;
 @@ -25697,7 +25691,7 @@ static Error ir_resolve_lazy_raw(CodeGen *codegen, AstNode *source_node, ConstEx
 Error ir_resolve_lazy(CodeGen *codegen, AstNode *source_node, ConstExprValue *val) {
     Error err;
-    if ((err = ir_resolve_lazy_raw(codegen, source_node, val))) {
+    if ((err = ir_resolve_lazy_raw(source_node, val))) {
         if (codegen->trace_err != nullptr && !source_node->already_traced_this_node) {
             source_node->already_traced_this_node = true;
             codegen->trace_err = add_error_note(codegen, codegen->trace_err, source_node,

test/compile_errors.zig+27

...	@@ -2,6 +2,33 @@ const tests = @import("tests.zig");	...	@@ -2,6 +2,33 @@ const tests = @import("tests.zig");
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
3		3
4	pub fn addCases(cases: *tests.CompileErrorContext) void {	4	pub fn addCases(cases: *tests.CompileErrorContext) void {
		5	cases.add(
		6	"alignment of enum field specified",
		7	\\const Number = enum {
		8	\\ a,
		9	\\ b align(i32),
		10	\\};
		11	\\export fn entry1() void {
		12	\\ var x: Number = undefined;
		13	\\}
		14	,
		15	"tmp.zig:3:13: error: structs and unions, not enums, support field alignment",
		16	"tmp.zig:1:16: note: consider 'union(enum)' here",
		17	);
		18
		19	cases.add(
		20	"bad alignment type",
		21	\\export fn entry1() void {
		22	\\ var x: []align(true) i32 = undefined;
		23	\\}
		24	\\export fn entry2() void {
		25	\\ var x: *align(f64(12.34)) i32 = undefined;
		26	\\}
		27	,
		28	"tmp.zig:2:20: error: expected type 'u29', found 'bool'",
		29	"tmp.zig:5:22: error: fractional component prevents float value 12.340000 from being casted to type 'u29'",
		30	);
		31
5	cases.addCase(x: {	32	cases.addCase(x: {
6	var tc = cases.create("variable in inline assembly template cannot be found",	33	var tc = cases.create("variable in inline assembly template cannot be found",
7	\\export fn entry() void {	34	\\export fn entry() void {