jimzah/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-11-28 08:02:32 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity
6d38dba72e
zig/test/behavior.zig

252 lines
10 KiB
Zig
Raw Normal View History

Narrow down behaviour test cases; this removes wasmtime-enabled check in tests
2020-05-18 16:45:06 +01:00
const builtin = @import("builtin");
stage2: improvements towards `zig test` * There is now a main_pkg in addition to root_pkg. They are usually the same. When using `zig test`, main_pkg is the user's source file and root_pkg has the test runner. * scanDecl no longer looks for test decls outside the package being tested. honoring `--test-filter` is still TODO. * test runner main function has a void return value rather than `anyerror!void` * Sema is improved to generate better AIR for for loops on slices. * Sema: fix incorrect capacity calculation in zirBoolBr * Sema: add compile errors for trying to use slice fields as an lvalue. * Sema: fix type coercion for error unions * Sema: fix analyzeVarRef generating garbage AIR * C codegen: fix renderValue for error unions with 0 bit payload * C codegen: implement function pointer calls * CLI: fix usage text Adds 4 new AIR instructions: * slice_len, slice_ptr: to get the ptr and len fields of a slice. * slice_elem_val, ptr_slice_elem_val: to get the element value of a slice, and a pointer to a slice. AstGen gains a new functionality: * One of the unused flags of struct decls is now used to indicate structs that are known to have non-zero size based on the AST alone.
2021-07-24 06:23:03 +01:00
test {
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 07:49:58 +00:00
_ = @import("behavior/align.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/alignof.zig");
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 07:49:58 +00:00
_ = @import("behavior/array.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
_ = @import("behavior/async_fn.zig");
Sema: implement `@truncate` for SIMD vectors
2022-03-15 22:09:23 +00:00
_ = @import("behavior/atomics.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
_ = @import("behavior/await_struct.zig");
stage2: handle void type in Elf DWARF gen Enable more behavior tests on both x64 and arm
2022-02-08 21:35:34 +00:00
_ = @import("behavior/basic.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/bit_shifting.zig");
Port bitcast.zig tests
2022-02-22 12:52:40 +00:00
_ = @import("behavior/bitcast.zig");
Add backend-specific skips for bitreverse, byteswap tests
2022-02-15 17:45:25 +00:00
_ = @import("behavior/bitreverse.zig");
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 07:49:58 +00:00
_ = @import("behavior/bool.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/bugs/394.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/bugs/421.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
_ = @import("behavior/bugs/529.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/bugs/624.zig");
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 07:49:58 +00:00
_ = @import("behavior/bugs/655.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/bugs/656.zig");
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 07:49:58 +00:00
_ = @import("behavior/bugs/679.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/bugs/704.zig");
stage2: fix mem{set,cpy} for non comptime mutable pointers
2022-03-04 08:06:25 +00:00
_ = @import("behavior/bugs/718.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/bugs/726.zig");
_ = @import("behavior/bugs/828.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
_ = @import("behavior/bugs/920.zig");
Move passing behavior tests Singular tests (such as in the bug ones) are moved to top level with exclusions for non-passing backends. The big behavior tests such as array_llvm and slice are moved to the inner scope with the C backend disabled. They all pass for the wasm backend now
2022-02-03 21:25:46 +00:00
_ = @import("behavior/bugs/1025.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/bugs/1076.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/bugs/1277.zig");
_ = @import("behavior/bugs/1310.zig");
_ = @import("behavior/bugs/1381.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/bugs/1421.zig");
_ = @import("behavior/bugs/1442.zig");
elf: add basic handling of .data section
2022-02-02 23:28:56 +00:00
_ = @import("behavior/bugs/1486.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/bugs/1500.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/bugs/1607.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/bugs/1735.zig");
Move passing behavior tests Singular tests (such as in the bug ones) are moved to top level with exclusions for non-passing backends. The big behavior tests such as array_llvm and slice are moved to the inner scope with the C backend disabled. They all pass for the wasm backend now
2022-02-03 21:25:46 +00:00
_ = @import("behavior/bugs/1741.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/bugs/1851.zig");
Move passing behavior tests Singular tests (such as in the bug ones) are moved to top level with exclusions for non-passing backends. The big behavior tests such as array_llvm and slice are moved to the inner scope with the C backend disabled. They all pass for the wasm backend now
2022-02-03 21:25:46 +00:00
_ = @import("behavior/bugs/1914.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/bugs/2006.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/bugs/2114.zig");
Add more entries to the list of stage1+stage2+CBE passing tests (#10094) * CBE: mark call.zig tests as passing * CBE: mark enum.zig tests as passing * CBE: mark defer.zig tests as passing * CBE: mark hasdecl.zig tests as passing * CBE: mark hasfield.zig tests as passing * CBE: mark ptrcast.zig tests as passing * CBE: mark bitcast.zig tests as passing * CBE: mark pub_enum.zig tests as passing * CBE: mark underscore.zig tests as passing * CBE: mark usingnamespace.zig tests as passing * CBE: mark bugs/655.zig tests as passing * CBE: mark bugs/679.zig tests as passing * CBE: mark bugs/704.zig tests as passing * CBE: mark bugs/1486.zig tests as passing * CBE: mark bugs/2346.zig tests as passing * CBE: mark bugs/2889.zig tests as passing * CBE: mark bugs/4560.zig tests as passing * CBE: mark bugs/4769_a.zig tests as passing * CBE: mark bugs/4769_b.zig tests as passing * CBE: mark bugs/6850.zig tests as passing
2021-11-04 18:24:46 +00:00
_ = @import("behavior/bugs/2346.zig");
Sema: remove unresolved inferred allocs Closes #2557
2022-10-17 13:19:16 +01:00
_ = @import("behavior/bugs/2557.zig");
Activate passing behavior tests This moves the single bugs behavior tests to the outer branch and disables the test cases for all non-passing backends. For the larger files, we move it up a single branch and disable it for the c backend. All test cases that do pass for the c backend however, are enabled.
2022-02-10 20:30:26 +00:00
_ = @import("behavior/bugs/2578.zig");
behavior and cases: more test coverage for old issues Closes #2622 Closes #2727 Closes #6047 Closes #6947 Closes #6656
2022-12-07 20:37:40 +00:00
_ = @import("behavior/bugs/2622.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/bugs/2692.zig");
behavior and cases: more test coverage for old issues Closes #2622 Closes #2727 Closes #6047 Closes #6947 Closes #6656
2022-12-07 20:37:40 +00:00
_ = @import("behavior/bugs/2727.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/bugs/2889.zig");
Activate passing behavior tests This moves the single bugs behavior tests to the outer branch and disables the test cases for all non-passing backends. For the larger files, we move it up a single branch and disable it for the c backend. All test cases that do pass for the c backend however, are enabled.
2022-02-10 20:30:26 +00:00
_ = @import("behavior/bugs/3007.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/bugs/3046.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/bugs/3112.zig");
_ = @import("behavior/bugs/3367.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/bugs/3384.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/bugs/3586.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/bugs/3742.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/bugs/3779.zig");
stage2: do not require function when evaluating typeOf We only care about the instructions type; it will never actually be codegen'd.
2022-02-26 16:06:06 +00:00
_ = @import("behavior/bugs/4328.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/bugs/4560.zig");
_ = @import("behavior/bugs/4769_a.zig");
_ = @import("behavior/bugs/4769_b.zig");
_ = @import("behavior/bugs/4954.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/bugs/5398.zig");
_ = @import("behavior/bugs/5413.zig");
_ = @import("behavior/bugs/5474.zig");
_ = @import("behavior/bugs/5487.zig");
behavior and cases: more test coverage for old issues Closes #2622 Closes #2727 Closes #6047 Closes #6947 Closes #6656
2022-12-07 20:37:40 +00:00
_ = @import("behavior/bugs/6047.zig");
Sema: implement `@truncate` for SIMD vectors
2022-03-15 22:09:23 +00:00
_ = @import("behavior/bugs/6456.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
_ = @import("behavior/bugs/6781.zig");
stage2: implement basics of airWrapErrUnionErr Enable more behavior tests for x86_64.
2022-01-05 22:51:26 +00:00
_ = @import("behavior/bugs/6850.zig");
behavior: add test coverage for slice and array-related issues Closes #10684 Closes #6905 Closes #8646
2022-12-07 19:57:00 +00:00
_ = @import("behavior/bugs/6905.zig");
behavior and cases: more test coverage for old issues Closes #2622 Closes #2727 Closes #6047 Closes #6947 Closes #6656
2022-12-07 20:37:40 +00:00
_ = @import("behavior/bugs/6947.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/bugs/7003.zig");
Sema: implement zirStructInit is_ref=true union
2022-03-10 18:00:07 +00:00
_ = @import("behavior/bugs/7047.zig");
test: recursively walk dir with tests Prune incremental tests by moving non-incremental behavior tests to behavior test suite instead.
2022-04-27 20:29:25 +01:00
_ = @import("behavior/bugs/7187.zig");
behavior: add test coverage for corrupted slice in release Closes #7325
2022-12-07 19:08:28 +00:00
_ = @import("behavior/bugs/7325.zig");
behavior: add test for #8277 Test `@sizeOf` reified union with zero-size payload fields. closes #8277
2023-01-03 05:24:48 +00:00
_ = @import("behavior/bugs/8277.zig");
behavior: add test coverage for slice and array-related issues Closes #10684 Closes #6905 Closes #8646
2022-12-07 19:57:00 +00:00
_ = @import("behavior/bugs/8646.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/bugs/9584.zig");
test: recursively walk dir with tests Prune incremental tests by moving non-incremental behavior tests to behavior test suite instead.
2022-04-27 20:29:25 +01:00
_ = @import("behavior/bugs/10138.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/bugs/10147.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/bugs/10970.zig");
behavior: add test coverage for slice and array-related issues Closes #10684 Closes #6905 Closes #8646
2022-12-07 19:57:00 +00:00
_ = @import("behavior/bugs/10684.zig");
Sema: fix resolution of inferred error sets Introduce `Module.ensureFuncBodyAnalyzed` and corresponding `Sema` function. This mirrors `ensureDeclAnalyzed` except also waits until the function body has been semantically analyzed, meaning that inferred error sets will have been populated. Resolving error sets can now emit a "unable to resolve inferred error set" error instead of producing an incorrect error set type. Resolving error sets now calls `ensureFuncBodyAnalyzed`. Closes #11046. `coerceInMemoryAllowedErrorSets` now does a lot more work to avoid resolving an inferred error set if possible. Same with `wrapErrorUnionSet`. Inferred error set types no longer check the `func` field to determine if they are equal. That was incorrect because an inline or comptime function call produces a unique error set which has the same `*Module.Fn` value for this field. Instead we use the `*Module.Fn.InferredErrorSet` pointers to test equality of inferred error sets.
2022-03-12 02:31:29 +00:00
_ = @import("behavior/bugs/11046.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/bugs/11100.zig");
Add test for issue #11139
2022-03-14 17:37:23 +00:00
_ = @import("behavior/bugs/11139.zig");
stage2: Fix panic on initializing comptime fields in tuple This resolves https://github.com/ziglang/zig/issues/11159 The problem was that: 1. We were not correctly deleting the field stores after recognizing that an array initializer was a comptime-known value. 2. LLVM was not checking that the final type had no runtime bits, and so would generate an invalid store. This also adds several test cases for related bugs, just to check these in for later work.
2022-03-15 21:00:33 +00:00
_ = @import("behavior/bugs/11159.zig");
_ = @import("behavior/bugs/11162.zig");
stage2: LLVM codegen of arrays should use type length, not value length It is possible for the value length to be longer than the type because we allow in-memory coercing of types such as `[5:0]u8` to `[5]u8`. In such a case, the value length is 6 but the type length if 5. The `.repeated` value type already got this right, so this is extending similar logic out to `.aggregate` and `.bytes`. Both scenarios are tested in behavior tests. Fixes #11165
2022-03-14 23:21:11 +00:00
_ = @import("behavior/bugs/11165.zig");
stage2: add test for fixed issue
2022-05-26 13:50:50 +01:00
_ = @import("behavior/bugs/11179.zig");
stage2: resolve type fully when resolving inferred allocs We must resolve the type fully so that pointer children (i.e. slices) are resolved. Additionally, we must resolve even if we can know the value at comptime because the `alloc_inferred` ZIR always produces a constant in the AIR. Fixes #11181
2022-03-15 20:29:54 +00:00
_ = @import("behavior/bugs/11181.zig");
AstGen: labeled blocks should always complete with a normal break They aren't inline blocks by nature of being labeled. Fixes #11213
2022-03-18 15:22:42 +00:00
_ = @import("behavior/bugs/11213.zig");
behavior: add test coverage for slicing zero length array field of struct Closes #11787
2022-12-07 17:00:52 +00:00
_ = @import("behavior/bugs/11787.zig");
AstGen: make loop body's ResultLoc .none Fixes #12555 Fixes #12551 Fixes #12455
2022-09-15 09:33:56 +01:00
_ = @import("behavior/bugs/11816.zig");
behavior: more test coverage Closes #12450 Closes #13113 Closes #12051 Closes #12092 Closes #12119 Closes #12142 Closes #12450 Closes #13113 Closes #11995 Closes #12000
2022-12-15 18:02:31 +00:00
_ = @import("behavior/bugs/11995.zig");
_ = @import("behavior/bugs/12000.zig");
stage2: Fix corrupted Type when de-referencing field pointer
2022-07-05 08:58:47 +01:00
_ = @import("behavior/bugs/12003.zig");
llvm: fix lowering of runtime refs to comptime-only decls When we want a runtime pointer to a zero-bit value we use an undef pointer, but what if we want a runtime pointer to a comptime-only value? Normally, if `T` is a comptime-only type such as `*const comptime_int`, then `*const T` would also be a comptime-only type, so anything referencing a comptime-only value is usually also comptime-only, and therefore not emitted to the executable. However, what if instead we have a `*const anyopaque` pointing to a comptime-only value? Certainly, `*const anyopaque` is a runtime type, and so we need some runtime value to store, even when it happens to be pointing to a comptime-only value. In this case we want to do the same thing as we do when pointing to a zero-bit value, so we use `hasRuntimeBits` to handle both cases instead of ignoring comptime. Closes #12025
2022-10-15 07:02:21 +01:00
_ = @import("behavior/bugs/12025.zig");
stage1: Fix seg-fault when slicing string literal with sentinel
2022-07-07 19:21:39 +01:00
_ = @import("behavior/bugs/12033.zig");
Add test case for #12043 This bug is already resolved, just want to make sure we don't lose the test case. Closes #12043
2022-10-05 13:34:49 +01:00
_ = @import("behavior/bugs/12043.zig");
behavior: more test coverage Closes #12450 Closes #13113 Closes #12051 Closes #12092 Closes #12119 Closes #12142 Closes #12450 Closes #13113 Closes #11995 Closes #12000
2022-12-15 18:02:31 +00:00
_ = @import("behavior/bugs/12051.zig");
_ = @import("behavior/bugs/12092.zig");
_ = @import("behavior/bugs/12119.zig");
_ = @import("behavior/bugs/12142.zig");
_ = @import("behavior/bugs/12169.zig");
stage2 astgen: Use `rl` semantics for `@Type` Resolves #12430.
2022-08-12 22:47:54 +01:00
_ = @import("behavior/bugs/12430.zig");
behavior: more test coverage Closes #12450 Closes #13113 Closes #12051 Closes #12092 Closes #12119 Closes #12142 Closes #12450 Closes #13113 Closes #11995 Closes #12000
2022-12-15 18:02:31 +00:00
_ = @import("behavior/bugs/12450.zig");
Sema: ensure resolveTypeFields is called for optional and error union types We call `sema.resolveTypeFields` in order to get the fields of structs and unions inserted into their data structures. If it isn't called, it can happen that the fields of a type is queried before those fields are inserted into (for instance) `Module.Union.fields`, which would result in a wrong 'no field named' error. Fixes: #12486
2022-08-26 09:37:17 +01:00
_ = @import("behavior/bugs/12486.zig");
Sema: resolve tuple default values before hashing Closes #12488
2022-10-17 14:39:44 +01:00
_ = @import("behavior/bugs/12488.zig");
Sema: fix comparisons between lazy and runtime values Closes #12498
2022-12-02 17:56:43 +00:00
_ = @import("behavior/bugs/12498.zig");
AstGen: make loop body's ResultLoc .none Fixes #12555 Fixes #12551 Fixes #12455
2022-09-15 09:33:56 +01:00
_ = @import("behavior/bugs/12551.zig");
Add test for #12571 Closes #12571
2022-12-14 23:43:48 +00:00
_ = @import("behavior/bugs/12571.zig");
Sema: fix resolveInferredErrorSet panic when generic inline function
2022-09-25 14:14:15 +01:00
_ = @import("behavior/bugs/12644.zig");
llvm: fix the `type` parameter of `GlobalAlias` Closes 12680
2022-09-04 16:44:45 +01:00
_ = @import("behavior/bugs/12680.zig");
remove references to stage1 in behavior tests Good riddance.
2022-12-07 02:06:48 +00:00
_ = @import("behavior/bugs/12723.zig");
_ = @import("behavior/bugs/12776.zig");
Sema: resolve lazy align in reifyStruct Closes #12786
2022-09-09 13:23:36 +01:00
_ = @import("behavior/bugs/12786.zig");
Sema: handle empty_struct_value in beginComptimePtrMutation Closes #12794
2022-09-09 13:19:51 +01:00
_ = @import("behavior/bugs/12794.zig");
Sema: handle comptime fields in field call bind Closes #12801
2022-09-09 22:53:26 +01:00
_ = @import("behavior/bugs/12801-1.zig");
_ = @import("behavior/bugs/12801-2.zig");
Sema: avoid using `pointerDecl` when dealing with slices Closes #12885
2022-09-23 15:36:37 +01:00
_ = @import("behavior/bugs/12885.zig");
Zir: handle ranges in `getMultiProng` Closes #12890
2022-10-03 12:05:55 +01:00
_ = @import("behavior/bugs/12890.zig");
Sema: add float128IntPartToBigInt to fix compare comptime float with int
2022-09-19 08:39:56 +01:00
_ = @import("behavior/bugs/12891.zig");
Sema: resolve struct layout in `zirStructInit` Closes #12911
2022-09-23 14:38:27 +01:00
_ = @import("behavior/bugs/12911.zig");
Sema: preserve volatileness when constructing field pointers Closes #12928
2022-09-23 10:00:02 +01:00
_ = @import("behavior/bugs/12928.zig");
Sema: avoid generic parameter error in nested function type Related to cd1833044ab7505bc101c85f59889bd3ea3fac80 Closes #12945
2022-09-23 22:08:42 +01:00
_ = @import("behavior/bugs/12945.zig");
llvm: fix bug lowering aggregate_init with a byref sentinel Closes #12972
2022-10-04 01:14:24 +01:00
_ = @import("behavior/bugs/12972.zig");
Type: correctly handle ABI align strat for optionals and error unions Closes #12984
2022-09-29 17:02:59 +01:00
_ = @import("behavior/bugs/12984.zig");
stage2: Be more strict about eliding loads This change makes any of the `*_val` instructions check whether it's safe to elide copies for by-ref types rather than performing this elision blindly. AIR instructions fixed: - .array_elem_val - .struct_field_val - .unwrap_errunion_payload - .try - .optional_payload These now all respect value semantics, as expected. P.S. Thanks to Andrew for the new way to approach this. Many of the lines here are from his recommended change, which comes with the significant advantage that loads are now as small as the intervening memory access allows. Co-authored by: Andrew Kelley <andrew@ziglang.org>
2022-11-10 18:58:34 +00:00
_ = @import("behavior/bugs/13064.zig");
_ = @import("behavior/bugs/13065.zig");
codegen: add support for lowering .field_ptr on a slice Closes #13068
2022-10-12 10:40:59 +01:00
_ = @import("behavior/bugs/13068.zig");
stage2: Be more strict about eliding loads This change makes any of the `*_val` instructions check whether it's safe to elide copies for by-ref types rather than performing this elision blindly. AIR instructions fixed: - .array_elem_val - .struct_field_val - .unwrap_errunion_payload - .try - .optional_payload These now all respect value semantics, as expected. P.S. Thanks to Andrew for the new way to approach this. Many of the lines here are from his recommended change, which comes with the significant advantage that loads are now as small as the intervening memory access allows. Co-authored by: Andrew Kelley <andrew@ziglang.org>
2022-11-10 18:58:34 +00:00
_ = @import("behavior/bugs/13069.zig");
Sema: handle noreturn in boolBr Closes #13112
2022-10-17 11:39:40 +01:00
_ = @import("behavior/bugs/13112.zig");
behavior: more test coverage Closes #12450 Closes #13113 Closes #12051 Closes #12092 Closes #12119 Closes #12142 Closes #12450 Closes #13113 Closes #11995 Closes #12000
2022-12-15 18:02:31 +00:00
_ = @import("behavior/bugs/13113.zig");
stage2 LLVM: Use a packed aggregate for union payload init Without the packed qualifier, the type layout that we use to initialize doesn't match the correct layout of the underlying storage, causing corrupted data and past-the-end writes.
2022-10-11 07:57:48 +01:00
_ = @import("behavior/bugs/13128.zig");
llvm: handle namespace like packed structs Closes #13159 Closes #13188
2022-10-24 12:46:14 +01:00
_ = @import("behavior/bugs/13159.zig");
Sema: add missing calls to `wip_captures.finalize` Closes #13171
2022-10-18 17:11:54 +01:00
_ = @import("behavior/bugs/13171.zig");
Fix tautological big_int tests.
2022-12-14 00:29:25 +00:00
_ = @import("behavior/bugs/13209.zig");
AstGen: fix `ref`ing inferred allocs Closes #13285
2022-10-24 15:30:47 +01:00
_ = @import("behavior/bugs/13285.zig");
Add test for #13366 Closes #13366
2022-12-10 02:50:37 +00:00
_ = @import("behavior/bugs/13366.zig");
Sema: resolve lazy align in zirReify for union fields Closes #13435
2022-11-03 23:56:23 +00:00
_ = @import("behavior/bugs/13435.zig");
llvm: implement `union_init` for packed unions Closes #13664
2022-11-27 13:37:48 +00:00
_ = @import("behavior/bugs/13664.zig");
AstGen: fix incorrect handling of source cursor with shift builtins Closes #13714
2022-11-30 13:22:34 +00:00
_ = @import("behavior/bugs/13714.zig");
TypedValue: fix handling of tuples represented as empty_struct_value
2022-12-08 20:21:49 +00:00
_ = @import("behavior/bugs/13785.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
_ = @import("behavior/byteswap.zig");
_ = @import("behavior/byval_arg_var.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/call.zig");
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 07:49:58 +00:00
_ = @import("behavior/cast.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/cast_int.zig");
stage2: type system treats fn ptr and body separately This commit updates stage2 to enforce the property that the syntax `fn()void` is a function *body* not a *pointer*. To get a pointer, the syntax `*const fn()void` is required. ZIR puts function alignment into the func instruction rather than the decl because this way it makes it into function types. LLVM backend respects function alignments. Struct and Union have methods `fieldSrcLoc` to help look up source locations of their fields. These trigger full loading, tokenization, and parsing of source files, so should only be called once it is confirmed that an error message needs to be printed. There are some nice new error hints for explaining why a type is required to be comptime, particularly for structs that contain function body types. `Type.requiresComptime` is now moved into Sema because it can fail and might need to trigger field type resolution. Comptime pointer loading takes into account types that do not have a well-defined memory layout and does not try to compute a byte offset for them. `fn()void` syntax no longer secretly makes a pointer. You get a function body type, which requires comptime. However a pointer to a function body can be runtime known (obviously). Compile errors that report "expected pointer, found ..." are factored out into convenience functions `checkPtrOperand` and `checkPtrType` and have a note about function pointers. Implemented `Value.hash` for functions, enum literals, and undefined values. stage1 is not updated to this (yet?), so some workarounds and disabled tests are needed to keep everything working. Should we update stage1 to these new type semantics? Yes probably because I don't want to add too much conditional compilation logic in the std lib for the different backends.
2022-01-21 07:49:58 +00:00
_ = @import("behavior/comptime_memory.zig");
Sema: implement `@truncate` for SIMD vectors
2022-03-15 22:09:23 +00:00
_ = @import("behavior/const_slice_child.zig");
remove references to stage1 in behavior tests Good riddance.
2022-12-07 02:06:48 +00:00
_ = @import("behavior/decltest.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/defer.zig");
fix overflow found while fuzzing * allow file level `union {}` to parse as tuple field this was found while fuzzing zls. * before this patch the input `union {}` crashed the parser. after this, it parses correctly just like `struct {}`. * adds behavior tests for both inputs `struct {}` and `union {}`, checking that each becomes a file level tuple field.
2022-12-23 21:10:04 +00:00
_ = @import("behavior/empty_tuple_fields.zig");
remove references to stage1 in behavior tests Good riddance.
2022-12-07 02:06:48 +00:00
_ = @import("behavior/empty_union.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/enum.zig");
_ = @import("behavior/error.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/eval.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/field_parent_ptr.zig");
Sema: detect comptime-known union initializations Follow a similar pattern as we already do for validate_array_init and validate_struct_init. I threw in a bit of behavior test cleanup on top of it.
2022-03-03 00:28:39 +00:00
_ = @import("behavior/floatop.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
_ = @import("behavior/fn.zig");
move more behavior tests to the "passing" section
2022-02-13 04:35:29 +00:00
_ = @import("behavior/fn_delegation.zig");
stage2: implement basics of airWrapErrUnionErr Enable more behavior tests for x86_64.
2022-01-05 22:51:26 +00:00
_ = @import("behavior/fn_in_struct_in_comptime.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/for.zig");
_ = @import("behavior/generics.zig");
stage2: implement basics of airWrapErrUnionErr Enable more behavior tests for x86_64.
2022-01-05 22:51:26 +00:00
_ = @import("behavior/hasdecl.zig");
ci: add test coverage for self-hosted arm and x86_64 backends
2022-01-06 22:23:29 +00:00
_ = @import("behavior/hasfield.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/if.zig");
_ = @import("behavior/import.zig");
_ = @import("behavior/incomplete_struct_param_tld.zig");
remove references to stage1 in behavior tests Good riddance.
2022-12-07 02:06:48 +00:00
_ = @import("behavior/inline_switch.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/int128.zig");
Sema: elide integer comparisons with guaranteed outcomes
2022-11-14 23:56:59 +00:00
_ = @import("behavior/int_comparison_elision.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/inttoptr.zig");
move more behavior tests to the "passing" section
2022-02-13 04:35:29 +00:00
_ = @import("behavior/ir_block_deps.zig");
codegen - lower str_lit to vector
2022-12-13 21:55:59 +00:00
_ = @import("behavior/lower_strlit_to_vector.zig");
behavior tests cleanup: promote math.zig
2022-03-03 08:23:50 +00:00
_ = @import("behavior/math.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/maximum_minimum.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/member_func.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/merge_error_sets.zig");
stage2: introduce anonymous struct literals
2022-03-02 06:46:57 +00:00
_ = @import("behavior/muladd.zig");
wasm: Implement genTypedValue for enums This makes all union test cases succeed. `rem` was also implemented as all we had to do is enable the instruction. Loading and storing values based on ABI-size was simplified to a direct abiSize() call. We also enabled all the newly passing test cases and disable them for all non-passing backends. All of those test cases were verified to see if they perhaps already pass for the c-backend.
2022-01-23 19:19:14 +00:00
_ = @import("behavior/namespace_depends_on_compile_var.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/null.zig");
Sema: implement comptime ptr store to optional payload and error union payload
2022-02-10 01:19:03 +00:00
_ = @import("behavior/optional.zig");
remove references to stage1 in behavior tests Good riddance.
2022-12-07 02:06:48 +00:00
_ = @import("behavior/packed-struct.zig");
_ = @import("behavior/packed_struct_explicit_backing_int.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/pointers.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/popcount.zig");
stage2: introduce anonymous struct literals
2022-03-02 06:46:57 +00:00
_ = @import("behavior/prefetch.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/ptrcast.zig");
stage2: introduce anonymous struct literals
2022-03-02 06:46:57 +00:00
_ = @import("behavior/pub_enum.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/ref_var_in_if_after_if_2nd_switch_prong.zig");
stage2: introduce anonymous struct literals
2022-03-02 06:46:57 +00:00
_ = @import("behavior/reflection.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/saturating_arithmetic.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
_ = @import("behavior/select.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/shuffle.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/sizeof_and_typeof.zig");
_ = @import("behavior/slice.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/slice_sentinel_comptime.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/src.zig");
stage2: introduce anonymous struct literals
2022-03-02 06:46:57 +00:00
_ = @import("behavior/struct.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/struct_contains_null_ptr_itself.zig");
stage2: lazy `@alignOf` Add a `target` parameter to every function that deals with Type and Value.
2022-03-22 07:23:54 +00:00
_ = @import("behavior/struct_contains_slice_of_itself.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/switch.zig");
wasm: Enable passing behavior tests This also adds some float-related instructions to MIR/Emit
2022-03-09 17:26:48 +00:00
_ = @import("behavior/switch_prong_err_enum.zig");
_ = @import("behavior/switch_prong_implicit_cast.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/this.zig");
disable failing behavior tests with -ofmt=c -target x86_64-windows and enable CI checks for the C backend on Windows.
2022-12-07 04:48:48 +00:00
_ = @import("behavior/threadlocal.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/translate_c_macros.zig");
move more behavior tests to the "passing" section
2022-02-13 04:35:29 +00:00
_ = @import("behavior/truncate.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/try.zig");
move more behavior tests to the "passing" section
2022-02-13 04:35:29 +00:00
_ = @import("behavior/tuple.zig");
remove references to stage1 in behavior tests Good riddance.
2022-12-07 02:06:48 +00:00
_ = @import("behavior/tuple_declarations.zig");
move more behavior tests to the "passing" section
2022-02-13 04:35:29 +00:00
_ = @import("behavior/type.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/type_info.zig");
stage2: improve `@typeName` * make it always return a fully qualified name. stage1 is inconsistent about this. * AstGen: fix anon_name_strategy to correctly be `func` when anon type creation happens in the operand of the return expression. * Sema: implement type names for the "function" naming strategy. * Put "enum", "union", "opaque", or "struct" in place of "anon" when creating respective anonymous Decl names. * std.testing: add `expectStringStartsWith`. Didn't end up using it after all. Also this enables the real test runner for stage2 LLVM backend (sans wasm32) since it works now.
2022-03-18 07:12:22 +00:00
_ = @import("behavior/typename.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/undefined.zig");
_ = @import("behavior/underscore.zig");
_ = @import("behavior/union.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/union_with_members.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/usingnamespace.zig");
move more behavior tests to the "passing" section
2022-02-13 04:35:29 +00:00
_ = @import("behavior/var_args.zig");
stage2: prevent UB in the LLVM backend * Sema: fix `zirTypeInfo` allocating with the wrong arenas for some stuff. * LLVM: split `airDbgInline` into two functions, one for each AIR tag. - remove the redundant copy to type_map_arena. This is the first thing that lowerDebugType does so this hack was probably just accidentally avoiding UB (which is still present prior to this commit). - don't store an inline fn inst into the di_map for the generic decl. - use a dummy function type for the debug info to avoid whatever UB is happening. - we are now ignoring the function type passed in with the dbg_inline_begin and dbg_inline_end. * behavior tests: prepare the vector tests to be enabled one at a time. Mitigates #11199.
2022-03-17 06:54:25 +00:00
_ = @import("behavior/vector.zig");
Port more behavior tests
2022-02-22 13:15:09 +00:00
_ = @import("behavior/void.zig");
_ = @import("behavior/while.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/widening.zig");
tests: prepare behavior tests for stage2
2021-04-29 22:51:21 +01:00
remove 'builtin.stage2_arch', Sema is smart enough now
2022-07-25 03:05:20 +01:00
if (builtin.cpu.arch == .wasm32) {
Update behavior tests
2022-03-03 18:16:30 +00:00
_ = @import("behavior/wasm.zig");
}
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
if (builtin.os.tag != .wasi) {
CBE: improve support for asm inputs This is not complete support for asm expressions, but allows a few more test cases from test/behavior/asm.zig to pass. Since the non-register inputs are named `input_${n}` they can cause name collisions: I'm wrapping the asm expressions in their own block to prevent that. Contextually, this change also makes test/behavior/asm.zig run for stage2, but skips individual tests for most backends (I only verified the C and LLVM backends successfully run one new test case) and the entire test file for aarch64, where it's running into preexisting shortcomings.
2022-03-20 21:04:28 +00:00
_ = @import("behavior/asm.zig");
behavior tests: disable failing stage1 test My previous commit added a new behavior test that passes for stage2 but I forgot to check whether it passes for stage1. Since it does not, it has to be disabled. Additionally, this commit organizes behavior tests; there is no longer a section of tests only passing for stage1. Instead, tests are disabled on an individual basis. There is an except for the file which has global assembly in it.
2022-03-23 21:06:07 +00:00
}
Port more behavior tests
2022-02-22 13:15:09 +00:00
if (builtin.zig_backend != .stage2_arm and
builtin.zig_backend != .stage2_x86_64 and
builtin.zig_backend != .stage2_aarch64 and
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
builtin.zig_backend != .stage2_wasm and
builtin.zig_backend != .stage2_c)
Port more behavior tests
2022-02-22 13:15:09 +00:00
{
stage2: Fix comptime array initialization This is a follow-up to 9dc98fba, which made comptime initialization patterns for union/struct more robust, especially when storing to comptime-known pointers (and globals). Resolves #13063.
2022-11-01 16:22:31 +00:00
_ = @import("behavior/bugs/13063.zig");
stage2 llvm: fix lowerDeclRefValue for function aliases
2022-03-21 11:25:57 +00:00
_ = @import("behavior/bugs/11227.zig");
llvm codegen: fix f16,f32,f64 nan bitcasts @bitCast from integer NaN representation to float NaN resulted in changed bits in float. This only happened with signaled NaN. - added test for signaled NaN - added tests for quiet NaN (for completeness) closes #14198
2023-01-04 20:18:17 +00:00
_ = @import("behavior/bugs/14198.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
_ = @import("behavior/export.zig");
disable regressed wasm32 behavior tests from LLVM 14
2022-07-05 23:46:12 +01:00
}
behavior: fix redefined exports
2022-10-06 11:33:21 +01:00
if (builtin.zig_backend != .stage2_wasm) {
stage2: fix mem{set,cpy} for non comptime mutable pointers
2022-03-04 08:06:25 +00:00
_ = @import("behavior/export_self_referential_type_info.zig");
organize behavior tests * Identify the ones that are passing and stop skipping them. * Flatten out the main behavior.zig file and have each individual test disable itself if it is not passing.
2022-03-18 22:02:52 +00:00
}
backport copy elision changes This commit contains everything from the copy-elision-2 branch that does not have to do with copy elision directly, but is generally useful for master branch. * All const values know their parents, when applicable, not just structs and unions. * Null pointers in const values are represented explicitly, rather than as a HardCodedAddr value of 0. * Rename "maybe" to "optional" in various code locations. * Separate DeclVarSrc and DeclVarGen * Separate PtrCastSrc and PtrCastGen * Separate CmpxchgSrc and CmpxchgGen * Represent optional error set as an integer, using the 0 value. In a const value, it uses nullptr. * Introduce type_has_one_possible_value and use it where applicable. * Fix debug builds not setting memory to 0xaa when storing undefined. * Separate the type of a variable from the const value of a variable. * Use copy_const_val where appropriate. * Rearrange structs to pack data more efficiently. * Move test/cases/* to test/behavior/* * Use `std.debug.assertOrPanic` in behavior tests instead of `std.debug.assert`. * Fix outdated slice syntax in docs.
2019-01-30 02:47:26 +00:00
}
Reference in New Issue Copy Permalink