0cd361219c
The big change in this commit is making `semaDecl` resolve the fields if
the Decl ends up being a struct or union. It needs to do this while
the `Sema` is still in scope, because it will have the resolved AIR
instructions that the field type expressions possibly reference. We do
this after the decl is populated and set to `complete` so that a `Decl`
may reference itself.
Everything else is fixes and improvements to make the test suite pass
again after making this change.
* New AIR instruction: `ptr_elem_ptr`
- Implemented for LLVM backend
* New Type tag: `type_info` which represents `std.builtin.TypeInfo`. It
is used by AstGen for the operand type of `@Type`.
* ZIR instruction `set_float_mode` uses `coerced_ty` to avoid
superfluous `as` instruction on operand.
* ZIR instruction `Type` uses `coerced_ty` to properly handle result
location type of operand.
* Fix two instances of `enum_nonexhaustive` Value Tag not handled
properly - it should generally be handled the same as `enum_full`.
* Fix struct and union field resolution not copying Type and Value
objects into its Decl arena.
* Fix enum tag value resolution discarding the ZIR=>AIR instruction map
for the child Sema, when they still needed to be accessed.
* Fix `zirResolveInferredAlloc` use-after-free in the AIR instructions
data array.
* Fix `elemPtrArray` not respecting const/mutable attribute of pointer
in the result type.
* Fix LLVM backend crashing when `updateDeclExports` is called before
`updateDecl`/`updateFunc` (which is, according to the API, perfectly
legal for the frontend to do).
* Fix LLVM backend handling element pointer of pointer-to-array. It
needed another index in the GEP otherwise LLVM saw the wrong type.
* Fix LLVM test cases not returning 0 from main, causing test failures.
Fixes a regression introduced in
6a5094872f.
* Implement comptime shift-right.
* Implement `@Type` for integers and `@TypeInfo` for integers.
* Implement union initialization syntax.
* Implement `zirFieldType` for unions.
* Implement `elemPtrArray` for a runtime-known operand.
* Make `zirLog2IntType` support RHS of shift being `comptime_int`. In
this case it returns `comptime_int`.
The motivating test case for this commit was originally:
```zig
test "example" {
var l: List(10) = undefined;
l.array[1] = 1;
}
fn List(comptime L: usize) type {
var T = u8;
return struct {
array: [L]T,
};
}
```
However I changed it to:
```zig
test "example" {
var l: List = undefined;
l.array[1] = 1;
}
const List = blk: {
const T = [10]u8;
break :blk struct {
array: T,
};
};
```
Which ended up being a similar, smaller problem. The former test case
will require a similar solution in the implementation of comptime
function calls - checking if the result of the function call is a struct
or union, and using the child `Sema` before it is destroyed to resolve
the fields.
229 lines
6.5 KiB
Zig
229 lines
6.5 KiB
Zig
const std = @import("std");
|
|
const TestContext = @import("../../src/test.zig").TestContext;
|
|
const build_options = @import("build_options");
|
|
|
|
// These tests should work with all platforms, but we're using linux_x64 for
|
|
// now for consistency. Will be expanded eventually.
|
|
const linux_x64 = std.zig.CrossTarget{
|
|
.cpu_arch = .x86_64,
|
|
.os_tag = .linux,
|
|
};
|
|
|
|
pub fn addCases(ctx: *TestContext) !void {
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("simple addition and subtraction", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn add(a: i32, b: i32) i32 {
|
|
\\ return a + b;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ var a: i32 = -5;
|
|
\\ const x = add(a, 7);
|
|
\\ var y = add(2, 0);
|
|
\\ y -= x;
|
|
\\ return y;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("shift right + left", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\pub export fn main() c_int {
|
|
\\ var i: u32 = 16;
|
|
\\ assert(i >> 1, 8);
|
|
\\ return 0;
|
|
\\}
|
|
\\fn assert(a: u32, b: u32) void {
|
|
\\ if (a != b) unreachable;
|
|
\\}
|
|
, "");
|
|
case.addCompareOutput(
|
|
\\pub export fn main() c_int {
|
|
\\ var i: u32 = 16;
|
|
\\ assert(i << 1, 32);
|
|
\\ return 0;
|
|
\\}
|
|
\\fn assert(a: u32, b: u32) void {
|
|
\\ if (a != b) unreachable;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("llvm hello world", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\extern fn puts(s: [*:0]const u8) c_int;
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ _ = puts("hello world!");
|
|
\\ return 0;
|
|
\\}
|
|
, "hello world!" ++ std.cstr.line_sep);
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("simple if statement", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn add(a: i32, b: i32) i32 {
|
|
\\ return a + b;
|
|
\\}
|
|
\\
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ assert(add(1,2) == 3);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("blocks", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\fn foo(ok: bool) i32 {
|
|
\\ const val: i32 = blk: {
|
|
\\ var x: i32 = 1;
|
|
\\ if (!ok) break :blk x + 9;
|
|
\\ break :blk x + 19;
|
|
\\ };
|
|
\\ return val + 10;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ assert(foo(false) == 20);
|
|
\\ assert(foo(true) == 30);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("nested blocks", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\fn foo(ok: bool) i32 {
|
|
\\ var val: i32 = blk: {
|
|
\\ const val2: i32 = another: {
|
|
\\ if (!ok) break :blk 10;
|
|
\\ break :another 10;
|
|
\\ };
|
|
\\ break :blk val2 + 10;
|
|
\\ };
|
|
\\ return val;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ assert(foo(false) == 10);
|
|
\\ assert(foo(true) == 20);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("while loops", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ var sum: u32 = 0;
|
|
\\ var i: u32 = 0;
|
|
\\ while (i < 5) : (i += 1) {
|
|
\\ sum += i;
|
|
\\ }
|
|
\\ assert(sum == 10);
|
|
\\ assert(i == 5);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("optionals", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ var opt_val: ?i32 = 10;
|
|
\\ var null_val: ?i32 = null;
|
|
\\
|
|
\\ var val1: i32 = opt_val.?;
|
|
\\ const val1_1: i32 = opt_val.?;
|
|
\\ var ptr_val1 = &(opt_val.?);
|
|
\\ const ptr_val1_1 = &(opt_val.?);
|
|
\\
|
|
\\ var val2: i32 = null_val orelse 20;
|
|
\\ const val2_2: i32 = null_val orelse 20;
|
|
\\
|
|
\\ var value: i32 = 20;
|
|
\\ var ptr_val2 = &(null_val orelse value);
|
|
\\
|
|
\\ const val3 = opt_val orelse 30;
|
|
\\ var val3_var = opt_val orelse 30;
|
|
\\
|
|
\\ assert(val1 == 10);
|
|
\\ assert(val1_1 == 10);
|
|
\\ assert(ptr_val1.* == 10);
|
|
\\ assert(ptr_val1_1.* == 10);
|
|
\\
|
|
\\ assert(val2 == 20);
|
|
\\ assert(val2_2 == 20);
|
|
\\ assert(ptr_val2.* == 20);
|
|
\\
|
|
\\ assert(val3 == 10);
|
|
\\ assert(val3_var == 10);
|
|
\\
|
|
\\ (null_val orelse val2) = 1234;
|
|
\\ assert(val2 == 1234);
|
|
\\
|
|
\\ (opt_val orelse val2) = 5678;
|
|
\\ assert(opt_val.? == 5678);
|
|
\\
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
|
|
{
|
|
var case = ctx.exeUsingLlvmBackend("for loop", linux_x64);
|
|
|
|
case.addCompareOutput(
|
|
\\fn assert(ok: bool) void {
|
|
\\ if (!ok) unreachable;
|
|
\\}
|
|
\\
|
|
\\pub export fn main() c_int {
|
|
\\ var x: u32 = 0;
|
|
\\ for ("hello") |_| {
|
|
\\ x += 1;
|
|
\\ }
|
|
\\ assert("hello".len == x);
|
|
\\ return 0;
|
|
\\}
|
|
, "");
|
|
}
|
|
}
|