2020-05-18 15:45:06 +00:00
|
|
|
const builtin = @import("builtin");
|
|
|
|
|
2021-07-24 05:23:03 +00: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");
|
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");
|
2022-02-08 21:35:34 +00:00
|
|
|
_ = @import("behavior/basic.zig");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/bit_shifting.zig");
|
2022-02-22 12:52:40 +00:00
|
|
|
_ = @import("behavior/bitcast.zig");
|
2022-02-15 17:45:25 +00:00
|
|
|
_ = @import("behavior/bitreverse.zig");
|
|
|
|
_ = @import("behavior/byteswap.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/byval_arg_var.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");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/bugs/394.zig");
|
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");
|
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");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/bugs/704.zig");
|
2022-03-04 08:06:25 +00:00
|
|
|
_ = @import("behavior/bugs/718.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/bugs/726.zig");
|
|
|
|
_ = @import("behavior/bugs/828.zig");
|
2022-02-03 21:25:46 +00:00
|
|
|
_ = @import("behavior/bugs/1025.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/bugs/1076.zig");
|
2021-11-30 23:14:18 +00:00
|
|
|
_ = @import("behavior/bugs/1111.zig");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/bugs/1277.zig");
|
|
|
|
_ = @import("behavior/bugs/1310.zig");
|
|
|
|
_ = @import("behavior/bugs/1381.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/bugs/1421.zig");
|
|
|
|
_ = @import("behavior/bugs/1442.zig");
|
2022-02-02 23:28:56 +00:00
|
|
|
_ = @import("behavior/bugs/1486.zig");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/bugs/1500.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/bugs/1607.zig");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/bugs/1735.zig");
|
2022-02-03 21:25:46 +00:00
|
|
|
_ = @import("behavior/bugs/1741.zig");
|
|
|
|
_ = @import("behavior/bugs/1914.zig");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/bugs/2006.zig");
|
2021-11-04 18:24:46 +00:00
|
|
|
_ = @import("behavior/bugs/2346.zig");
|
2022-02-10 20:30:26 +00:00
|
|
|
_ = @import("behavior/bugs/2578.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/bugs/2692.zig");
|
|
|
|
_ = @import("behavior/bugs/2889.zig");
|
2022-02-10 20:30:26 +00:00
|
|
|
_ = @import("behavior/bugs/3007.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/bugs/3046.zig");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/bugs/3112.zig");
|
|
|
|
_ = @import("behavior/bugs/3367.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/bugs/3384.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/bugs/3586.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/bugs/3742.zig");
|
2022-02-26 16:06:06 +00:00
|
|
|
_ = @import("behavior/bugs/4328.zig");
|
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");
|
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");
|
2022-01-05 22:51:26 +00:00
|
|
|
_ = @import("behavior/bugs/6850.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/bugs/7003.zig");
|
2022-03-10 18:00:07 +00:00
|
|
|
_ = @import("behavior/bugs/7047.zig");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/bugs/7250.zig");
|
2022-03-09 10:24:18 +00:00
|
|
|
_ = @import("behavior/bugs/11100.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/bugs/10970.zig");
|
2022-03-12 02:31:29 +00:00
|
|
|
_ = @import("behavior/bugs/11046.zig");
|
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");
|
|
|
|
_ = @import("behavior/comptime_memory.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/defer.zig");
|
|
|
|
_ = @import("behavior/enum.zig");
|
|
|
|
_ = @import("behavior/error.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/field_parent_ptr.zig");
|
2022-03-03 00:28:39 +00:00
|
|
|
_ = @import("behavior/floatop.zig");
|
2022-02-13 04:35:29 +00:00
|
|
|
_ = @import("behavior/fn_delegation.zig");
|
2022-01-05 22:51:26 +00:00
|
|
|
_ = @import("behavior/fn_in_struct_in_comptime.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/fn.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/for.zig");
|
|
|
|
_ = @import("behavior/generics.zig");
|
2022-01-05 22:51:26 +00:00
|
|
|
_ = @import("behavior/hasdecl.zig");
|
2022-01-06 22:23:29 +00:00
|
|
|
_ = @import("behavior/hasfield.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/if.zig");
|
|
|
|
_ = @import("behavior/import.zig");
|
|
|
|
_ = @import("behavior/incomplete_struct_param_tld.zig");
|
|
|
|
_ = @import("behavior/int_div.zig");
|
|
|
|
_ = @import("behavior/inttoptr.zig");
|
2022-02-13 04:35:29 +00:00
|
|
|
_ = @import("behavior/ir_block_deps.zig");
|
2022-03-03 08:23:50 +00:00
|
|
|
_ = @import("behavior/math.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/member_func.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/merge_error_sets.zig");
|
2022-03-02 06:46:57 +00:00
|
|
|
_ = @import("behavior/muladd.zig");
|
2022-01-23 19:19:14 +00:00
|
|
|
_ = @import("behavior/namespace_depends_on_compile_var.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/null.zig");
|
2022-02-10 01:19:03 +00:00
|
|
|
_ = @import("behavior/optional.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/pointers.zig");
|
2022-03-02 06:46:57 +00:00
|
|
|
_ = @import("behavior/prefetch.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/ptrcast.zig");
|
2022-03-02 06:46:57 +00:00
|
|
|
_ = @import("behavior/pub_enum.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/ref_var_in_if_after_if_2nd_switch_prong.zig");
|
2022-03-02 06:46:57 +00:00
|
|
|
_ = @import("behavior/reflection.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/sizeof_and_typeof.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/slice_sentinel_comptime.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/slice.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/src.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/struct_contains_null_ptr_itself.zig");
|
2022-03-02 06:46:57 +00:00
|
|
|
_ = @import("behavior/struct.zig");
|
2022-03-09 17:26:48 +00:00
|
|
|
_ = @import("behavior/switch_prong_err_enum.zig");
|
|
|
|
_ = @import("behavior/switch_prong_implicit_cast.zig");
|
2022-03-03 00:28:39 +00:00
|
|
|
_ = @import("behavior/switch.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/this.zig");
|
2022-02-13 04:35:29 +00:00
|
|
|
_ = @import("behavior/truncate.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/try.zig");
|
2022-02-13 04:35:29 +00:00
|
|
|
_ = @import("behavior/tuple.zig");
|
|
|
|
_ = @import("behavior/type.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/type_info.zig");
|
|
|
|
_ = @import("behavior/undefined.zig");
|
|
|
|
_ = @import("behavior/underscore.zig");
|
|
|
|
_ = @import("behavior/union.zig");
|
|
|
|
_ = @import("behavior/usingnamespace.zig");
|
2022-02-13 04:35:29 +00:00
|
|
|
_ = @import("behavior/var_args.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/void.zig");
|
|
|
|
_ = @import("behavior/while.zig");
|
2021-04-29 21:51:21 +00:00
|
|
|
|
2022-03-04 01:31:55 +00:00
|
|
|
if (builtin.stage2_arch == .wasm32) {
|
2022-03-03 18:16:30 +00:00
|
|
|
_ = @import("behavior/wasm.zig");
|
|
|
|
}
|
|
|
|
|
2022-01-27 20:23:28 +00:00
|
|
|
if (builtin.zig_backend != .stage1) {
|
|
|
|
_ = @import("behavior/decltest.zig");
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
builtin.zig_backend != .stage2_wasm)
|
|
|
|
{
|
|
|
|
// Tests that pass for stage1, llvm backend, C backend
|
2022-03-06 16:29:17 +00:00
|
|
|
_ = @import("behavior/bugs/421.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/bugs/9584.zig");
|
|
|
|
_ = @import("behavior/cast_int.zig");
|
|
|
|
_ = @import("behavior/eval.zig");
|
2022-03-04 08:06:25 +00:00
|
|
|
_ = @import("behavior/export_self_referential_type_info.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/int128.zig");
|
|
|
|
_ = @import("behavior/translate_c_macros.zig");
|
2022-03-11 20:52:56 +00:00
|
|
|
_ = @import("behavior/union_with_members.zig");
|
2021-10-28 23:37:12 +00:00
|
|
|
|
2022-02-22 13:15:09 +00:00
|
|
|
if (builtin.zig_backend != .stage2_c) {
|
|
|
|
// Tests that pass for stage1 and the llvm backend.
|
|
|
|
_ = @import("behavior/atomics.zig");
|
2022-03-10 18:00:07 +00:00
|
|
|
_ = @import("behavior/export.zig");
|
2022-02-22 13:15:09 +00:00
|
|
|
_ = @import("behavior/maximum_minimum.zig");
|
|
|
|
_ = @import("behavior/popcount.zig");
|
|
|
|
_ = @import("behavior/saturating_arithmetic.zig");
|
|
|
|
_ = @import("behavior/widening.zig");
|
2022-02-22 13:04:12 +00:00
|
|
|
_ = @import("behavior/bugs/2114.zig");
|
2022-03-10 11:04:55 +00:00
|
|
|
_ = @import("behavior/bugs/3779.zig");
|
2022-03-10 18:00:07 +00:00
|
|
|
_ = @import("behavior/bugs/10147.zig");
|
2022-03-11 12:25:15 +00:00
|
|
|
_ = @import("behavior/shuffle.zig");
|
2021-12-05 11:34:50 +00:00
|
|
|
|
2022-02-22 13:15:09 +00:00
|
|
|
if (builtin.zig_backend == .stage1) {
|
|
|
|
// Tests that only pass for the stage1 backend.
|
|
|
|
if (builtin.os.tag != .wasi) {
|
|
|
|
_ = @import("behavior/asm.zig");
|
|
|
|
_ = @import("behavior/async_fn.zig");
|
|
|
|
}
|
|
|
|
_ = @import("behavior/await_struct.zig");
|
|
|
|
_ = @import("behavior/bugs/529.zig");
|
|
|
|
_ = @import("behavior/bugs/920.zig");
|
|
|
|
_ = @import("behavior/bugs/1120.zig");
|
|
|
|
_ = @import("behavior/bugs/1851.zig");
|
|
|
|
_ = @import("behavior/bugs/6456.zig");
|
|
|
|
_ = @import("behavior/bugs/6781.zig");
|
|
|
|
_ = @import("behavior/bugs/7027.zig");
|
|
|
|
_ = @import("behavior/const_slice_child.zig");
|
|
|
|
_ = @import("behavior/select.zig");
|
|
|
|
_ = @import("behavior/struct_contains_slice_of_itself.zig");
|
|
|
|
_ = @import("behavior/typename.zig");
|
|
|
|
_ = @import("behavior/vector.zig");
|
2021-10-28 23:37:12 +00:00
|
|
|
}
|
2021-04-29 21:51:21 +00:00
|
|
|
}
|
2020-06-02 11:26:49 +00:00
|
|
|
}
|
2019-01-30 02:47:26 +00:00
|
|
|
}
|