├── .builds ├── debian-amd64.yml ├── debian-arm64.yml └── fedora-amd64.yml ├── .clang-format ├── .gitignore ├── Dockerfile ├── GRAMMAR ├── LICENSE ├── Makefile ├── README.md ├── ast.c ├── bin ├── sunder-platform ├── sunder-run └── sunder-test ├── codegen.c ├── cst.c ├── env ├── eval.c ├── examples ├── big-integer-calculator.sunder ├── brainfuck.sunder ├── cat.sunder ├── examples.build.sh ├── examples.clean.sh ├── ffi │ ├── calling-c-from-sunder │ │ ├── calling-c-from-sunder.c │ │ └── calling-c-from-sunder.sunder │ └── calling-sunder-from-c │ │ ├── calling-sunder-from-c.c │ │ └── calling-sunder-from-c.sunder ├── fizzbuzz.sunder ├── greet.sunder ├── hello.sunder └── ls.sunder ├── lex.c ├── lib ├── c │ └── c.sunder ├── std │ └── std.sunder └── sys │ ├── common.sunder │ ├── sys.amd64-linux.sunder │ ├── sys.arm64-linux.sunder │ ├── sys.arm64-macos.sunder │ ├── sys.h │ ├── sys.wasm32-emscripten.html │ └── sys.wasm32-emscripten.sunder ├── misc ├── alignof.c ├── dump.c ├── errno-list.c ├── errno-list.sh ├── setup-emsdk.sh ├── sys-defs.c ├── tag-release.sh ├── types.c └── types.gdb ├── order.c ├── parse.c ├── resolve.c ├── sunder-compile.c ├── sunder.c ├── sunder.h ├── tests ├── abi-function-casting.test.sunder ├── bool-can-be-hash-map-key.test.sunder ├── byte-can-be-hash-map-key.test.sunder ├── c-backend.test.sunder ├── constant-folding.test.sunder ├── data.txt ├── decl-constant-automatic-type-deduction.test.sunder ├── decl-constant-uninit.test.sunder ├── decl-constant-with-function-type.test.sunder ├── decl-extern-function.test.sunder ├── decl-extern-type.test.sunder ├── decl-extern-variable.test.sunder ├── decl-variable-automatic-type-deduction.test.sunder ├── decl-variable-uninit.test.sunder ├── duplicate-local-constant.test.sunder ├── duplicate-local-variable.test.sunder ├── error-array-size-exceeds-maximum-allowable-object-size-large-constant.test.sunder ├── error-array-size-exceeds-maximum-allowable-object-size-overflow.test.sunder ├── error-call-invalid-argument-count.test.sunder ├── error-call-invalid-argument-type.test.sunder ├── error-call-non-function-type.test.sunder ├── error-circular-dependency.test.sunder ├── error-constant-expr-call.test.sunder ├── error-decl-constant-identifier-is-not-a-constant.test.sunder ├── error-decl-constant-type-unsized-automatic-type-deduction.test.sunder ├── error-decl-constant-type-unsized.test.sunder ├── error-decl-constant-uninit-use.test.sunder ├── error-decl-constant-uninit-without-type.test.sunder ├── error-decl-enum-duplicate-value.test.sunder ├── error-decl-enum-value-not-an-integer.test.sunder ├── error-decl-enum-value-out-of-range-gt-max.test.sunder ├── error-decl-enum-value-out-of-range-lt-min.test.sunder ├── error-decl-extend-not-a-constant-or-function.test.sunder ├── error-decl-extern-var-type-unsized.test.sunder ├── error-decl-variable-type-unsized-automatic-type-deduction.test.sunder ├── error-decl-variable-type-unsized.test.sunder ├── error-decl-variable-uninit-without-type.test.sunder ├── error-dereference-non-pointer-type-postfix.test.sunder ├── error-dereference-non-pointer-type-prefix.test.sunder ├── error-duplicate-global-name.test.sunder ├── error-duplicate-parameter-name.test.sunder ├── error-expr-access-dot-member-constant-as-value.test.sunder ├── error-expr-access-dot-member-function-as-value.test.sunder ├── error-expr-access-dot-member-not-in-type.test.sunder ├── error-expr-access-dot-member-template-as-value.test.sunder ├── error-expr-access-dot-member-variable-with-template-instantiation.test.sunder ├── error-expr-access-dot-non-struct-non-union-lhs.test.sunder ├── error-expr-access-index-array-lvalue-out-of-bounds-var.test.sunder ├── error-expr-access-index-array-rvalue-out-of-bounds-let.test.sunder ├── error-expr-access-index-array-rvalue-out-of-bounds-var.test.sunder ├── error-expr-access-index-lhs-slice-in-constant-expr.test.sunder ├── error-expr-access-index-lhs-slice-lvalue-in-constant-expr.test.sunder ├── error-expr-access-index-lhs-slice-lvalue-out-of-bounds.test.sunder ├── error-expr-access-index-lhs-slice-rvalue-out-of-bounds.test.sunder ├── error-expr-access-slice-array-lvalue-begin-out-of-bounds-let.test.sunder ├── error-expr-access-slice-array-lvalue-begin-out-of-bounds-var.test.sunder ├── error-expr-access-slice-array-lvalue-end-lt-begin-out-of-bounds-let.test.sunder ├── error-expr-access-slice-array-lvalue-end-lt-begin-out-of-bounds-var.test.sunder ├── error-expr-access-slice-array-lvalue-end-out-of-bounds-let.test.sunder ├── error-expr-access-slice-array-lvalue-end-out-of-bounds-var.test.sunder ├── error-expr-access-slice-invalid-begin-type.test.sunder ├── error-expr-access-slice-invalid-end-type.test.sunder ├── error-expr-access-slice-invalid-lhs-rvalue-array.test.sunder ├── error-expr-access-slice-invalid-lhs-type.test.sunder ├── error-expr-access-slice-lhs-slice-in-constant-expr.test.sunder ├── error-expr-access-slice-lhs-slice-lvalue-begin-out-of-bounds.test.sunder ├── error-expr-access-slice-lhs-slice-lvalue-end-lt-begin-out-of-bounds.test.sunder ├── error-expr-access-slice-lhs-slice-lvalue-end-out-of-bounds.test.sunder ├── error-expr-access-slice-lhs-slice-rvalue-begin-out-of-bounds.test.sunder ├── error-expr-access-slice-lhs-slice-rvalue-end-lt-begin-out-of-bounds.test.sunder ├── error-expr-access-slice-lhs-slice-rvalue-end-out-of-bounds.test.sunder ├── error-expr-binary-add-integer-out-of-range-constant.test.sunder ├── error-expr-binary-add-integer-out-of-range-s16.test.sunder ├── error-expr-binary-add-integer-out-of-range-s32.test.sunder ├── error-expr-binary-add-integer-out-of-range-s64.test.sunder ├── error-expr-binary-add-integer-out-of-range-s8.test.sunder ├── error-expr-binary-add-integer-out-of-range-u16.test.sunder ├── error-expr-binary-add-integer-out-of-range-u32.test.sunder ├── error-expr-binary-add-integer-out-of-range-u64.test.sunder ├── error-expr-binary-add-integer-out-of-range-u8.test.sunder ├── error-expr-binary-arithmetic-incompatible-types.test.sunder ├── error-expr-binary-arithmetic-invalid-xhs.test.sunder ├── error-expr-binary-bitwise-type-unsized.test.sunder ├── error-expr-binary-div-divide-by-zero-constant-integer.test.sunder ├── error-expr-binary-div-divide-by-zero-s16.test.sunder ├── error-expr-binary-div-divide-by-zero-s32.test.sunder ├── error-expr-binary-div-divide-by-zero-s64.test.sunder ├── error-expr-binary-div-divide-by-zero-s8.test.sunder ├── error-expr-binary-div-divide-by-zero-u16.test.sunder ├── error-expr-binary-div-divide-by-zero-u32.test.sunder ├── error-expr-binary-div-divide-by-zero-u64.test.sunder ├── error-expr-binary-div-divide-by-zero-u8.test.sunder ├── error-expr-binary-eq-array.test.sunder ├── error-expr-binary-eq-slice.test.sunder ├── error-expr-binary-eq-void.test.sunder ├── error-expr-binary-ge-array.test.sunder ├── error-expr-binary-ge-function.test.sunder ├── error-expr-binary-ge-slice.test.sunder ├── error-expr-binary-ge-void.test.sunder ├── error-expr-binary-gt-array.test.sunder ├── error-expr-binary-gt-function.test.sunder ├── error-expr-binary-gt-slice.test.sunder ├── error-expr-binary-gt-void.test.sunder ├── error-expr-binary-le-array.test.sunder ├── error-expr-binary-le-function.test.sunder ├── error-expr-binary-le-slice.test.sunder ├── error-expr-binary-le-void.test.sunder ├── error-expr-binary-lt-array.test.sunder ├── error-expr-binary-lt-function.test.sunder ├── error-expr-binary-lt-slice.test.sunder ├── error-expr-binary-lt-void.test.sunder ├── error-expr-binary-mul-integer-out-of-range-constant.test.sunder ├── error-expr-binary-mul-integer-out-of-range-s16.test.sunder ├── error-expr-binary-mul-integer-out-of-range-s32.test.sunder ├── error-expr-binary-mul-integer-out-of-range-s64.test.sunder ├── error-expr-binary-mul-integer-out-of-range-s8.test.sunder ├── error-expr-binary-mul-integer-out-of-range-u16.test.sunder ├── error-expr-binary-mul-integer-out-of-range-u32.test.sunder ├── error-expr-binary-mul-integer-out-of-range-u64.test.sunder ├── error-expr-binary-mul-integer-out-of-range-u8.test.sunder ├── error-expr-binary-ne-array.test.sunder ├── error-expr-binary-ne-slice.test.sunder ├── error-expr-binary-ne-void.test.sunder ├── error-expr-binary-shift-with-non-integer-lhs.test.sunder ├── error-expr-binary-shift-with-non-usize-rhs.test.sunder ├── error-expr-binary-shiftl-with-unsized-lhs.test.sunder ├── error-expr-binary-shiftr-with-unsized-lhs.test.sunder ├── error-expr-binary-sub-integer-out-of-range-constant.test.sunder ├── error-expr-binary-sub-integer-out-of-range-s16.test.sunder ├── error-expr-binary-sub-integer-out-of-range-s32.test.sunder ├── error-expr-binary-sub-integer-out-of-range-s64.test.sunder ├── error-expr-binary-sub-integer-out-of-range-s8.test.sunder ├── error-expr-binary-sub-integer-out-of-range-u16.test.sunder ├── error-expr-binary-sub-integer-out-of-range-u32.test.sunder ├── error-expr-binary-sub-integer-out-of-range-u64.test.sunder ├── error-expr-binary-sub-integer-out-of-range-u8.test.sunder ├── error-expr-binary-wrapping-add-with-unsized-type.test.sunder ├── error-expr-binary-wrapping-mul-with-unsized-type.test.sunder ├── error-expr-binary-wrapping-sub-with-unsized-type.test.sunder ├── error-expr-call-member-function-invalid-argument-count.test.sunder ├── error-expr-call-member-function-invalid-argument-type.test.sunder ├── error-expr-call-member-function-no-self-parameter-function-has-non-zero-number-of-parameters.test.sunder ├── error-expr-call-member-function-no-self-parameter-function-has-zero-number-of-parameters.test.sunder ├── error-expr-call-member-function-no-template-instantiation.test.sunder ├── error-expr-call-member-function-not-in-struct.test.sunder ├── error-expr-call-member-function-type-has-no-member-function-nested-type.test.sunder ├── error-expr-call-member-function-type-has-no-member-function.test.sunder ├── error-expr-call-member-variable-function-with-template-instantiation.test.sunder ├── error-expr-cast-constant-from-pointer.test.sunder ├── error-expr-cast-from-f32-to-integer-out-of-range-in-constant-expression.test.sunder ├── error-expr-cast-from-f32-to-integer-out-of-range.test.sunder ├── error-expr-cast-from-f32-to-unsized-integer.test.sunder ├── error-expr-cast-from-f64-to-integer-out-of-range-in-constant-expression.test.sunder ├── error-expr-cast-from-f64-to-integer-out-of-range.test.sunder ├── error-expr-cast-from-f64-to-unsized-integer.test.sunder ├── error-expr-cast-from-type-unsized-integer-to-byte-out-of-range.test.sunder ├── error-expr-cast-from-type-unsized-integer-to-sized-integer-out-of-range.test.sunder ├── error-expr-cast-from-unsized-integer-to-f32-out-of-range.test.sunder ├── error-expr-cast-from-unsized-integer-to-f64-out-of-range.test.sunder ├── error-expr-cast-function-to-function-mismatched-parameter-count.test.sunder ├── error-expr-cast-function-to-function-mismatched-parameter-type.test.sunder ├── error-expr-cast-function-to-function-mismatched-return-type.test.sunder ├── error-expr-cast-invalid-cast.test.sunder ├── error-expr-cast-to-type-unsized.test.sunder ├── error-expr-init-struct-initializer-wrong-type.test.sunder ├── error-expr-init-union-expected-one-initializer-got-two.test.sunder ├── error-expr-init-union-expected-one-initializer-got-zero.test.sunder ├── error-expr-init-union-expected-zero-initializers-got-one.test.sunder ├── error-expr-init-union-initializer-wrong-type.test.sunder ├── error-expr-invalid-infix-token.test.sunder ├── error-expr-invalid-prefix-token.test.sunder ├── error-expr-list-not-array-or-slice-type.test.sunder ├── error-expr-member-access-union-with-different-value.test.sunder ├── error-expr-member-access-union-with-no-value.test.sunder ├── error-expr-sizeof-type-unsized.test.sunder ├── error-expr-slice-not-slice-type.test.sunder ├── error-expr-unary-addressof-non-static-object-in-compile-time-expression.test.sunder ├── error-expr-unary-arithmetic-invalid-rhs.test.sunder ├── error-expr-unary-bitnot-with-unsized-rhs.test.sunder ├── error-expr-unary-neg-integer-out-of-range-constant.test.sunder ├── error-expr-unary-neg-integer-out-of-range-s16.test.sunder ├── error-expr-unary-neg-integer-out-of-range-s32.test.sunder ├── error-expr-unary-neg-integer-out-of-range-s64.test.sunder ├── error-expr-unary-neg-integer-out-of-range-s8.test.sunder ├── error-expr-unary-neg-uinteger.test.sunder ├── error-expr-unary-wrapping-neg-uinteger.test.sunder ├── error-expr-unary-wrapping-neg-with-unsized-type.test.sunder ├── error-extend-declaration-before-non-extend-declaration.test.sunder ├── error-func-does-not-end-with-a-return-statement-no-stmts.test.sunder ├── error-func-does-not-end-with-a-return-statement-some-stmts.test.sunder ├── error-func-parameter-type-unsized.test.sunder ├── error-func-return-type-unsized.test.sunder ├── error-identifier-is-not-a-type.test.sunder ├── error-ieee754-missing-digit-after-decimal-separator.test.sunder ├── error-ieee754-non-decimal-base.test.sunder ├── error-illegal-for-range-index-type.test.sunder ├── error-illegal-type-conversion-in-assignment.test.sunder ├── error-illegal-type-conversion-in-declaration.test.sunder ├── error-illegal-type-conversion-of-array-element.test.sunder ├── error-integer-literal-no-digits.test.sunder ├── error-integer-literal-out-of-range-gt-max-byte.test.sunder ├── error-integer-literal-out-of-range-gt-max-s8.test.sunder ├── error-integer-literal-out-of-range-lt-min-byte.test.sunder ├── error-integer-literal-out-of-range-lt-min-s8.test.sunder ├── error-integer-literal-unknown-suffix.test.sunder ├── error-invalid-character.test.sunder ├── error-invalid-escape-sequence-bytes-literal.test.sunder ├── error-invalid-escape-sequence-character-literal.test.sunder ├── error-invalid-escape-sequence-hex-literal-first-digit.test.sunder ├── error-invalid-escape-sequence-hex-literal-second-digit.test.sunder ├── error-invalid-for-range-begin-type.test.sunder ├── error-invalid-for-range-end-type.test.sunder ├── error-invalid-non-printable-character-in-bytes-literal.test.sunder ├── error-invalid-non-printable-character-in-character-literal.test.sunder ├── error-invalid-sigil.test.sunder ├── error-invalid-stmt-op-assign.test.sunder ├── error-main-invalid-function-signature.test.sunder ├── error-main-is-not-defined-as-a-function.test.sunder ├── error-main-is-not-defined.test.sunder ├── error-nested-function-declaration.test.sunder ├── error-null-pointer-dereference.test.sunder ├── error-return-expr-in-function-with-void-return.test.sunder ├── error-return-invalid-type.test.sunder ├── error-return-void-in-function-with-non-void-return.test.sunder ├── error-shows-fully-qualified-struct-symbol-name.test.sunder ├── error-slice-list-ellipsis-element.test.sunder ├── error-stmt-assert-is-not-a-bool.test.sunder ├── error-stmt-assign-incompatible-type.test.sunder ├── error-stmt-break-outside-of-loop.test.sunder ├── error-stmt-continue-outside-of-loop.test.sunder ├── error-stmt-expr-type-unsized.test.sunder ├── error-stmt-if-non-boolean-condition.test.sunder ├── error-stmt-switch-case-invalid-enum-value.test.sunder ├── error-stmt-switch-case-invalid-type.test.sunder ├── error-stmt-switch-else-is-not-last.test.sunder ├── error-stmt-switch-expr-not-an-enum.test.sunder ├── error-struct-access-uninit-member.test.sunder ├── error-struct-contains-incomplete-struct.test.sunder ├── error-struct-contains-incomplete-union.test.sunder ├── error-struct-contains-unsized-member.test.sunder ├── error-struct-duplicate-member-initializer.test.sunder ├── error-struct-duplicate-member-name.test.sunder ├── error-struct-illegal-type-conversion.test.sunder ├── error-struct-member-parse-error.test.sunder ├── error-struct-missing-member-initializer.test.sunder ├── error-template-function-invalid-argument-count.test.sunder ├── error-template-function-no-parameters.test.sunder ├── error-template-stack-report-invalid-template-member-function.test.sunder ├── error-template-stack-report-invalid-template-struct.test.sunder ├── error-template-type-must-be-instantiated.test.sunder ├── error-type-struct-duplicate-member-name.test.sunder ├── error-type-union-duplicate-member-name.test.sunder ├── error-unexpected-end-of-line-in-bytes-literal.test.sunder ├── error-unexpected-end-of-line-in-character-literal.test.sunder ├── error-unexpected-prefix-token-end-of-file.test.sunder ├── error-union-contains-incomplete-struct.test.sunder ├── error-union-contains-incomplete-union.test.sunder ├── error-union-contains-unsized-member.test.sunder ├── error-union-duplicate-member-name.test.sunder ├── error-use-of-incomplete-type.test.sunder ├── error-use-of-type-as-expression.test.sunder ├── error-use-of-undeclared-identifier-expr.test.sunder ├── error-use-of-undeclared-identifier-type.test.sunder ├── example-alias.test.sunder ├── example-array.test.sunder ├── example-byte.test.sunder ├── example-enum.test.sunder ├── example-extend.test.sunder ├── example-fibonacci.test.sunder ├── example-hello.test.sunder ├── example-ieee754.test.sunder ├── example-interface.test.sunder ├── example-iterator.test.sunder ├── example-literal-bytes.test.sunder ├── example-literal-character.test.sunder ├── example-pointer.test.sunder ├── example-slice-list.test.sunder ├── example-slice.test.sunder ├── example-struct.test.sunder ├── example-switch.test.sunder ├── example-template-functions.test.sunder ├── example-template-structs.test.sunder ├── example-union.test.sunder ├── expr-access-index.test.sunder ├── expr-access-slice.test.sunder ├── expr-alignof.test.sunder ├── expr-array-ellipsis.test.sunder ├── expr-array.test.sunder ├── expr-binary-and.test.sunder ├── expr-binary-bitand.test.sunder ├── expr-binary-bitor.test.sunder ├── expr-binary-bitxor.test.sunder ├── expr-binary-div.test.sunder ├── expr-binary-eq.test.sunder ├── expr-binary-ge.test.sunder ├── expr-binary-gt.test.sunder ├── expr-binary-le.test.sunder ├── expr-binary-lt.test.sunder ├── expr-binary-ne.test.sunder ├── expr-binary-or.test.sunder ├── expr-binary-rem.test.sunder ├── expr-binary-shift-left.test.sunder ├── expr-binary-shift-right.test.sunder ├── expr-binary-wrapping-add.test.sunder ├── expr-binary-wrapping-mul.test.sunder ├── expr-binary-wrapping-sub.test.sunder ├── expr-call-member-function-builtin-type.test.sunder ├── expr-call-member-function-lvalue.test.sunder ├── expr-call-member-function-rvalue.test.sunder ├── expr-call-trailing-comma.test.sunder ├── expr-cast-from-bool-to-bool.test.sunder ├── expr-cast-from-byte-to-byte.test.sunder ├── expr-cast-from-function-to-pointer.test.sunder ├── expr-cast-from-integer-to-ieee754.test.sunder ├── expr-cast-from-pointer-to-function.test.sunder ├── expr-cast-from-type-unsized-integer.test.sunder ├── expr-cast.test.sunder ├── expr-defined.test.sunder ├── expr-embed.test.sunder ├── expr-f32-nan-constant-expression.test.sunder ├── expr-f32-negative-inf-constant-expression.test.sunder ├── expr-f32-positive-inf-constant-expression.test.sunder ├── expr-f64-nan-constant-expression.test.sunder ├── expr-f64-negative-inf-constant-expression.test.sunder ├── expr-f64-positive-inf-constant-expression.test.sunder ├── expr-fileof.test.sunder ├── expr-integer.test.sunder ├── expr-lineof.test.sunder ├── expr-sizeof.test.sunder ├── expr-struct-initializer-order.test.sunder ├── expr-struct-initializer-uninit.test.sunder ├── expr-unary-addressof.test.sunder ├── expr-unary-bitnot.test.sunder ├── expr-unary-countof.test.sunder ├── expr-unary-neg.test.sunder ├── expr-unary-not.test.sunder ├── expr-unary-startof.test.sunder ├── expr-unary-wrapping-neg.test.sunder ├── f32-can-be-hash-map-key.test.sunder ├── f64-can-be-hash-map-key.test.sunder ├── github-issue-100.test.sunder ├── github-issue-101-explicit-type.test.sunder ├── github-issue-101-implicit-type.test.sunder ├── github-issue-105.test.sunder ├── github-issue-114.test.sunder ├── github-issue-118.test.sunder ├── github-issue-119.test.sunder ├── github-issue-120.test.sunder ├── github-issue-120 │ └── module.sunder ├── github-issue-122.test.sunder ├── github-issue-123.test.sunder ├── github-issue-125.test.sunder ├── github-issue-125 │ └── import.sunder ├── github-issue-126.test.sunder ├── github-issue-128.test.sunder ├── github-issue-133.test.sunder ├── github-issue-134.test.sunder ├── github-issue-139.test.sunder ├── github-issue-76.test.sunder ├── github-issue-77.test.sunder ├── github-issue-77 │ └── import.sunder ├── github-issue-84.test.sunder ├── github-issue-93.test.sunder ├── github-issue-94.test.sunder ├── github-issue-95.test.sunder ├── implcit-cast-from-typed-pointer-to-any-pointer.test.sunder ├── import-directory.test.sunder ├── import-platform-specific.test.sunder ├── import-platform-specific │ ├── module-with-no-platform-specific-override.sunder │ ├── module.amd64.sunder │ ├── module.arm64.sunder │ ├── module.linux.sunder │ ├── module.macos.sunder │ ├── module.pdp11.sunder │ └── module.sunder ├── import.test.sunder ├── import │ ├── a.sunder │ ├── b.sunder │ └── c │ │ └── c.sunder ├── integer-literal-unsized.test.sunder ├── namespace.test.sunder ├── namespace │ ├── import1.sunder │ ├── import2.sunder │ └── import3.sunder ├── operator-precedence.test.sunder ├── order-independent-top-level-declarations.test.sunder ├── reserved-c-identifiers.test.sunder ├── std-argument_iterator.test.sunder ├── std-argument_parser-error-missing-required-option-argument.test.sunder ├── std-argument_parser-error-missing-required-option.test.sunder ├── std-argument_parser-error-option-does-not-accept-argument.test.sunder ├── std-argument_parser-error-unrecognized-option.test.sunder ├── std-argument_parser.test.sunder ├── std-ascii-is_digit.test.sunder ├── std-ascii-is_letter.test.sunder ├── std-ascii-is_lowercase.test.sunder ├── std-ascii-is_uppercase.test.sunder ├── std-ascii-is_whitespace.test.sunder ├── std-ascii-to_lowercase.test.sunder ├── std-ascii-to_uppercase.test.sunder ├── std-ascii-view_trimmed.test.sunder ├── std-big_integer-can-be-hash-map-key.test.sunder ├── std-big_integer-constants.test.sunder ├── std-big_integer.test.sunder ├── std-bool-eq.test.sunder ├── std-bool-format.test.sunder ├── std-bool-init_from_str.test.sunder ├── std-byte-format.test.sunder ├── std-byte-max.test.sunder ├── std-byte-min.test.sunder ├── std-cstr-count.test.sunder ├── std-directory-create-and-remove.test.sunder ├── std-directory.test.sunder ├── std-error-check-for-specific-error-info.test.sunder ├── std-f32-format.test.sunder ├── std-f32-init_from_str.test.sunder ├── std-f64-format.test.sunder ├── std-f64-init_from_str.test.sunder ├── std-file-append.test.sunder ├── std-file-create-and-remove.test.sunder ├── std-file-open-path-too-long.test.sunder ├── std-file-open-write-and-append.test.sunder ├── std-file-read-and-write.test.sunder ├── std-file-read.test.sunder ├── std-file-seek-and-tell.test.sunder ├── std-file-write-to-bad-fd.test.sunder ├── std-file-write.test.sunder ├── std-file.test.sunder ├── std-fini.test.sunder ├── std-formatter.test.sunder ├── std-forward_align.test.sunder ├── std-general_allocator-allocate-reallocate-deallocate.test.sunder ├── std-general_allocator_iterator.test.sunder ├── std-global_allocator.test.sunder ├── std-hash_map-element-fini-order.test.sunder ├── std-hash_map-insert-vs-update.test.sunder ├── std-hash_map-iterator.test.sunder ├── std-hash_map-remove-vs-erase.test.sunder ├── std-hash_map.test.sunder ├── std-hash_map_iterator.test.sunder ├── std-hash_set-element-fini-order.test.sunder ├── std-hash_set-init_difference.test.sunder ├── std-hash_set-init_intersection.test.sunder ├── std-hash_set-init_symmetric_difference.test.sunder ├── std-hash_set-init_union.test.sunder ├── std-hash_set-insert-vs-update.test.sunder ├── std-hash_set-iterator.test.sunder ├── std-hash_set-remove-vs-erase.test.sunder ├── std-hash_set.test.sunder ├── std-hash_set_iterator.test.sunder ├── std-int-abs.test.sunder ├── std-int-compare.test.sunder ├── std-int-format.test.sunder ├── std-int-init_from_str.test.sunder ├── std-int-isqrt.test.sunder ├── std-int-max.test.sunder ├── std-int-min.test.sunder ├── std-linear_allocator-allocate-reallocate-deallocate.test.sunder ├── std-max.test.sunder ├── std-min.test.sunder ├── std-new-delete-with-allocator.test.sunder ├── std-new-delete.test.sunder ├── std-null.test.sunder ├── std-null_allocator-allocate.test.sunder ├── std-null_allocator-constants.test.sunder ├── std-null_allocator-deallocate.test.sunder ├── std-null_allocator-reallocate.test.sunder ├── std-null_allocator-the.test.sunder ├── std-optional-constant.test.sunder ├── std-optional-init-empty.test.sunder ├── std-optional-init-value.test.sunder ├── std-panic_format.test.sunder ├── std-ptr-add.test.sunder ├── std-ptr-null.test.sunder ├── std-ptr-sub.test.sunder ├── std-read_all.test.sunder ├── std-read_all_with_allocator.test.sunder ├── std-read_line.test.sunder ├── std-read_line_with_allocator.test.sunder ├── std-result-init-error.test.sunder ├── std-result-init-value.test.sunder ├── std-slice-copy.test.sunder ├── std-slice-fill.test.sunder ├── std-slice-new-resize-delete-with-allocator.test.sunder ├── std-slice-new-resize-delete.test.sunder ├── std-slice-reverse.test.sunder ├── std-slice_iterator.test.sunder ├── std-sort.test.sunder ├── std-sort_with_comparator.test.sunder ├── std-str-compare.test.sunder ├── std-str-contains.test.sunder ├── std-str-cut.test.sunder ├── std-str-ends_with.test.sunder ├── std-str-find.test.sunder ├── std-str-format.test.sunder ├── std-str-rfind.test.sunder ├── std-str-split.test.sunder ├── std-str-split_with_allocator.test.sunder ├── std-str-starts_with.test.sunder ├── std-str_reader.test.sunder ├── std-str_writer.test.sunder ├── std-string-assign.test.sunder ├── std-string-can-be-hash-map-key.test.sunder ├── std-string-cstr.test.sunder ├── std-string-format.test.sunder ├── std-string-init.test.sunder ├── std-string-init_assign.test.sunder ├── std-string-init_from_format.test.sunder ├── std-string-init_from_format_with_allocator.test.sunder ├── std-string-init_from_str.test.sunder ├── std-string-init_from_str_with_allocator.test.sunder ├── std-string-init_with_allocator.test.sunder ├── std-string-write.test.sunder ├── std-swap.test.sunder ├── std-unreachable.test.sunder ├── std-vector-assign.test.sunder ├── std-vector-element-fini-order.test.sunder ├── std-vector-init.test.sunder ├── std-vector-init_assign.test.sunder ├── std-vector-init_with_allocator.test.sunder ├── std-vector-insert.test.sunder ├── std-vector-iterator.test.sunder ├── std-vector-push-pop.test.sunder ├── std-vector-remove.test.sunder ├── std-vector-reserve.test.sunder ├── std-vector-resize.test.sunder ├── std-vector-with-no-elements-added-does-not-allocate.test.sunder ├── std-void-format.test.sunder ├── std-write_all.test.sunder ├── std-write_format-ambiguous-rbrace.test.sunder ├── std-write_format-extra-format-args.test.sunder ├── std-write_format-missing-format-args.test.sunder ├── std-write_format-unmatched-lbrace-end-of-string.test.sunder ├── std-write_format-unmatched-lbrace.test.sunder ├── std-write_format-unmatched-rbrace-end-of-string.test.sunder ├── std-write_format-unmatched-rbrace.test.sunder ├── std-write_format.test.sunder ├── std-zeroed.test.sunder ├── stmt-add-assign.test.sunder ├── stmt-add-wrapping-assign.test.sunder ├── stmt-assert.test.sunder ├── stmt-bitand-assign.test.sunder ├── stmt-bitor-assign.test.sunder ├── stmt-bitxor-assign.test.sunder ├── stmt-break.test.sunder ├── stmt-continue.test.sunder ├── stmt-defer.test.sunder ├── stmt-div-assign.test.sunder ├── stmt-for-expr.test.sunder ├── stmt-for-range.test.sunder ├── stmt-if.test.sunder ├── stmt-mul-assign.test.sunder ├── stmt-mul-wrapping-assign.test.sunder ├── stmt-rem-assign.test.sunder ├── stmt-return-array.test.sunder ├── stmt-return-void-with-side-effects.test.sunder ├── stmt-return-void.test.sunder ├── stmt-shiftl-assign.test.sunder ├── stmt-shiftr-assign.test.sunder ├── stmt-sub-assign.test.sunder ├── stmt-sub-wrapping-assign.test.sunder ├── stmt-when.test.sunder ├── sunder-test-7-hashes.test.sunder ├── sunder-test-8-hashes.test.sunder ├── sunder-test-9-hashes.test.sunder ├── symbol-starts-with-type.test.sunder ├── sys-dump.test.sunder ├── sys-max-align.test.sunder ├── type-struct.test.sunder ├── type-symbol-starting-with-scope-resolution-operator.test.sunder ├── type-typeof.test.sunder ├── type-union.test.sunder ├── util │ └── argv.sunder ├── void-can-be-has-map-key.test.sunder ├── warning-stmt-assign-lhs-is-constant.sunder └── warning-unused-symbol.test.sunder └── util.c /.builds/debian-arm64.yml: -------------------------------------------------------------------------------- 1 | image: debian/unstable 2 | arch: arm64 3 | packages: 4 | - build-essential 5 | sources: 6 | - https://git.sr.ht/~ashn/sunder 7 | tasks: 8 | - c99-release: | 9 | cd sunder 10 | make clean check examples CFLAGS='$(C99_REL)' 11 | triggers: 12 | - action: email 13 | condition: failure 14 | to: "" 15 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | sunder-compile 2 | 3 | examples/big-integer-calculator 4 | examples/brainfuck 5 | examples/cat 6 | examples/fizzbuzz 7 | examples/greet 8 | examples/hello 9 | examples/ls 10 | examples/ffi/calling-c-from-sunder/calling-c-from-sunder 11 | examples/ffi/calling-sunder-from-c/calling-sunder-from-c 12 | 13 | *.tmp* 14 | a.out* 15 | *.out 16 | *.o 17 | *.asm 18 | *.tmp 19 | *.log 20 | *.html 21 | *.wasm 22 | 23 | emsdk/ 24 | 25 | !lib/sys/sys.wasm32-emscripten.html 26 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | # Build the linux/amd64 Sunder image. 2 | # $ docker buildx build --platform=linux/amd64 --tag sunder . 3 | # 4 | # Create a Sunder development environment. 5 | # $ docker run --rm --interactive --tty --volume "$(pwd)":/sunder sunder 6 | # 7 | # Remove the Sunder image. 8 | # $ docker image rm sunder 9 | 10 | FROM debian:stable-slim 11 | 12 | ARG DEBIAN_FRONTEND=noninteractive 13 | RUN apt update -y && apt upgrade -y && apt update -y 14 | RUN apt install -y build-essential clang clang-format 15 | RUN mkdir -p /sunder 16 | 17 | WORKDIR /sunder 18 | VOLUME ["/sunder"] 19 | 20 | CMD bash -c 'SUNDER_HOME=/sunder; source /sunder/env; exec bash' 21 | -------------------------------------------------------------------------------- /bin/sunder-run: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | set -u 3 | 4 | PROGNAME=$(basename "$0") 5 | usage() { 6 | cat < 2 | 3 | int x = 100; 4 | int const y = 200; 5 | 6 | void 7 | yell(char const* str) 8 | { 9 | printf("%s!\n", str); 10 | } 11 | -------------------------------------------------------------------------------- /examples/ffi/calling-c-from-sunder/calling-c-from-sunder.sunder: -------------------------------------------------------------------------------- 1 | import "c"; 2 | import "std"; 3 | 4 | extern var x: sint; 5 | extern var y: sint; # const 6 | extern func puts(str: *char) sint; 7 | extern func yell(str: *char) sint; 8 | 9 | func main() void { 10 | puts(startof("hello")); 11 | yell(startof("HELLO")); 12 | 13 | x = x + 1; 14 | var sum = x + y; 15 | std::print_format_line( 16 | std::out(), 17 | "x + y = {}", 18 | (:[]std::formatter)[std::formatter::init[[sint]](&sum)]); 19 | } 20 | -------------------------------------------------------------------------------- /examples/ffi/calling-sunder-from-c/calling-sunder-from-c.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern int examplelib_x; 5 | extern int const examplelib_y; 6 | extern void examplelib_puts(char const* start, size_t count); 7 | extern void examplelib_yell(char const* start, size_t count); 8 | 9 | int 10 | main(void) 11 | { 12 | char const* lower = "hello"; 13 | examplelib_puts(lower, strlen(lower)); 14 | 15 | char const* upper = "HELLO"; 16 | examplelib_yell(upper, strlen(upper)); 17 | 18 | examplelib_x += 1; 19 | printf("x + y = %d\n", examplelib_x + examplelib_y); 20 | } 21 | -------------------------------------------------------------------------------- /examples/ffi/calling-sunder-from-c/calling-sunder-from-c.sunder: -------------------------------------------------------------------------------- 1 | namespace examplelib; 2 | import "std"; 3 | 4 | var x = 100s32; 5 | let y = 200s32; 6 | 7 | func puts(start: *byte, count: usize) void { 8 | var str = (:[]byte){start, count}; 9 | std::print_line(std::out(), str); 10 | } 11 | 12 | func yell(start: *byte, count: usize) void { 13 | var str = (:[]byte){start, count}; 14 | std::print_format_line( 15 | std::out(), 16 | "{}!", 17 | (:[]std::formatter)[std::formatter::init[[[]byte]](&str)]); 18 | } 19 | -------------------------------------------------------------------------------- /examples/fizzbuzz.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | let N = 100u; 5 | for i in 1:N+1 { 6 | if i % 3 == 0 and i % 5 == 0 { 7 | std::print_line(std::out(), "FizzBuzz"); 8 | continue; 9 | } 10 | if i % 3 == 0 { 11 | std::print_line(std::out(), "Fizz"); 12 | continue; 13 | } 14 | if i % 5 == 0 { 15 | std::print_line(std::out(), "Buzz"); 16 | continue; 17 | } 18 | std::print_format_line(std::out(), "{}", (:[]std::formatter)[std::formatter::init[[usize]](&i)]); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /examples/hello.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | std::print_line(std::out(), "Hello, world!"); 5 | } 6 | -------------------------------------------------------------------------------- /misc/errno-list.c: -------------------------------------------------------------------------------- 1 | // Similar to errno-list.sh, but uses strerror directly instead of errno(1). 2 | // 3 | // clang misc/errno-list.c && ./a.out 4 | // emcc -o errno-list.html misc/errno-list.c -sSINGLE_FILE --shell-file lib/sys/sys.wasm32-emscripten.html 5 | #include 6 | #include 7 | 8 | // Maximum errno value to check. Assumes that the POSIX system uses errno 9 | // values ascending from zero up to this maximum value. 10 | #define ERRNO_MAX 200 11 | 12 | int 13 | main(void) 14 | { 15 | printf("let ERRORS = (:[][]byte)[\n"); 16 | for (int e = 0; e <= ERRNO_MAX; ++e) { 17 | printf(" \"[system error %d] %s\",\n", e, strerror(e)); 18 | } 19 | printf("];\n"); 20 | } 21 | -------------------------------------------------------------------------------- /misc/setup-emsdk.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | set -e 4 | 5 | usage() { 6 | echo "Usage: $(basename $0)" 7 | echo "Download and activate the latest version of the Emscripten toolchain." 8 | echo "This script should be run from the project root directory." 9 | } 10 | 11 | if [ $# != '0' ]; then 12 | usage 13 | exit 1 14 | fi 15 | 16 | 17 | if [ ! -d emsdk/ ]; then 18 | echo '>> Cloning the Emscripten SDK...' 19 | git clone https://github.com/emscripten-core/emsdk.git 20 | fi 21 | 22 | echo '>> Installing latest emsdk...' 23 | (cd emsdk/ && ./emsdk install latest) 24 | 25 | echo '>> Activating latest emsdk...' 26 | (cd emsdk && ./emsdk activate latest) 27 | -------------------------------------------------------------------------------- /misc/tag-release.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | set -e 4 | set -x 5 | VERSION=$(date -u +"%Y.%m.%d") 6 | git tag -a "${VERSION}" -m "Release ${VERSION}" 7 | -------------------------------------------------------------------------------- /tests/data.txt: -------------------------------------------------------------------------------- 1 | TEST DATA FILE LINE 1 2 | TEST DATA FILE LINE 2 3 | -------------------------------------------------------------------------------- /tests/decl-constant-automatic-type-deduction.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | struct s { 4 | var foo: u32; 5 | var bar: u32; 6 | } 7 | 8 | let a = 0xAAu8; 9 | let b = 0xBBBBu16; 10 | let c = 0xCCCCCCCCu32; 11 | let d = 0xDDDDDDDDDDDDDDDDu64; 12 | let e = (:s){.foo = 0xDEADBEEF, .bar = 0xCAFEF00D}; 13 | 14 | func main() void { 15 | let f = (:s32)0xFFFFu16; 16 | 17 | sys::dump[[u8]](a); 18 | sys::dump[[u16]](b); 19 | sys::dump[[u32]](c); 20 | sys::dump[[u64]](d); 21 | sys::dump[[s]](e); 22 | sys::dump[[s32]](f); 23 | } 24 | ################################################################################ 25 | # AA 26 | # BB BB 27 | # CC CC CC CC 28 | # DD DD DD DD DD DD DD DD 29 | # EF BE AD DE 0D F0 FE CA 30 | # FF FF 00 00 31 | -------------------------------------------------------------------------------- /tests/decl-constant-with-function-type.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | let fn_one: func() ssize = one; 4 | let fn_sub: func(ssize, ssize) ssize = sub; 5 | let fn_exit: func(s32) void = sys::exit; 6 | 7 | func one() ssize { 8 | return 1s; 9 | } 10 | 11 | func sub(lhs: ssize, rhs: ssize) ssize { 12 | return lhs - rhs; 13 | } 14 | 15 | func main() void { 16 | fn_exit( 17 | (:s32)fn_sub( 18 | fn_sub( 19 | 2s, 20 | fn_one()), 21 | fn_one())); 22 | } 23 | -------------------------------------------------------------------------------- /tests/decl-extern-function.test.sunder: -------------------------------------------------------------------------------- 1 | extern func foo() void; 2 | extern func foo() void; # duplicate extern declaration should be allowed 3 | 4 | func main() void { } 5 | -------------------------------------------------------------------------------- /tests/decl-extern-type.test.sunder: -------------------------------------------------------------------------------- 1 | extern type foo; 2 | extern type foo; # duplicate extern declaration should be allowed 3 | 4 | func main() void { } 5 | -------------------------------------------------------------------------------- /tests/decl-extern-variable.test.sunder: -------------------------------------------------------------------------------- 1 | extern var foo: ssize; 2 | extern var foo: ssize; # duplicate extern declaration should be allowed 3 | 4 | func main() void { } 5 | -------------------------------------------------------------------------------- /tests/decl-variable-automatic-type-deduction.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | struct s { 4 | var foo: u32; 5 | var bar: u32; 6 | } 7 | 8 | var a = 0xAAu8; 9 | var b = 0xBBBBu16; 10 | var c = 0xCCCCCCCCu32; 11 | var d = 0xDDDDDDDDDDDDDDDDu64; 12 | var e = (:s){.foo = 0xDEADBEEF, .bar = 0xCAFEF00D}; 13 | 14 | func main() void { 15 | var f = (:s32)0xFFFFu16; 16 | 17 | sys::dump[[u8]](a); 18 | sys::dump[[u16]](b); 19 | sys::dump[[u32]](c); 20 | sys::dump[[u64]](d); 21 | sys::dump[[s]](e); 22 | sys::dump[[s32]](f); 23 | } 24 | ################################################################################ 25 | # AA 26 | # BB BB 27 | # CC CC CC CC 28 | # DD DD DD DD DD DD DD DD 29 | # EF BE AD DE 0D F0 FE CA 30 | # FF FF 00 00 31 | -------------------------------------------------------------------------------- /tests/duplicate-local-constant.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | let foo = 1u16; 5 | sys::dump[[u16]](foo); 6 | 7 | let foo = 2u32; 8 | sys::dump[[u32]](foo); 9 | } 10 | ################################################################################ 11 | # 01 00 12 | # 02 00 00 00 13 | -------------------------------------------------------------------------------- /tests/duplicate-local-variable.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var foo = 1u16; 5 | sys::dump[[u16]](foo); 6 | 7 | var foo = 2u32; 8 | sys::dump[[u32]](foo); 9 | } 10 | ################################################################################ 11 | # 01 00 12 | # 02 00 00 00 13 | -------------------------------------------------------------------------------- /tests/error-array-size-exceeds-maximum-allowable-object-size-large-constant.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | sizeof([(:usize)u64::MAX]byte); 5 | } 6 | ################################################################################ 7 | # [error-array-size-exceeds-maximum-allowable-object-size-large-constant.test.sunder:4] error: array size exceeds the maximum allowable object size 8 | # sizeof([(:usize)u64::MAX]byte); 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-array-size-exceeds-maximum-allowable-object-size-overflow.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | sizeof([(:usize)s64::MAX][2]byte); 5 | } 6 | ################################################################################ 7 | # [error-array-size-exceeds-maximum-allowable-object-size-overflow.test.sunder:4] error: array size exceeds the maximum allowable object size 8 | # sizeof([(:usize)s64::MAX][2]byte); 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-call-invalid-argument-count.test.sunder: -------------------------------------------------------------------------------- 1 | func foo(a_: usize, b_: ssize, c_: bool) ssize { 2 | return 123s; 3 | } 4 | 5 | func main() void { 6 | foo(1u, 2s); 7 | } 8 | ################################################################################ 9 | # [error-call-invalid-argument-count.test.sunder:6] error: function with type `func(usize, ssize, bool) ssize` expects 3 argument(s) (2 provided) 10 | # foo(1u, 2s); 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-call-invalid-argument-type.test.sunder: -------------------------------------------------------------------------------- 1 | func foo(a_: usize, b_: ssize, c_: bool) ssize { 2 | return 123s; 3 | } 4 | 5 | func main() void { 6 | foo( 7 | 1u, # valid 8 | 2s, # valid 9 | 3s # invalid (should be bool) 10 | ); 11 | } 12 | ################################################################################ 13 | # [error-call-invalid-argument-type.test.sunder:9] error: incompatible argument type `ssize` (expected `bool`) 14 | # 3s # invalid (should be bool) 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-call-non-function-type.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = 1s; 2 | func main() void { 3 | foo(3s, 5s); 4 | } 5 | ################################################################################ 6 | # [error-call-non-function-type.test.sunder:3] error: non-callable type `ssize` used in function call expression 7 | # foo(3s, 5s); 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-circular-dependency.test.sunder: -------------------------------------------------------------------------------- 1 | let baz: ssize = foo; 2 | let bar: ssize = baz; 3 | let foo: ssize = bar; 4 | ################################################################################ 5 | # [error-circular-dependency.test.sunder:1] error: circular dependency created by declaration of `baz` 6 | # let baz: ssize = foo; 7 | # ^ 8 | # info: declaration of `baz` (line 1) depends on `foo` (line 3) 9 | # info: declaration of `foo` (line 3) depends on `bar` (line 2) 10 | # info: declaration of `bar` (line 2) depends on `baz` (line 1) 11 | -------------------------------------------------------------------------------- /tests/error-constant-expr-call.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = f() + 1; 2 | 3 | func f() ssize { 4 | return 123s; 5 | } 6 | ################################################################################ 7 | # [error-constant-expr-call.test.sunder:1] error: constant expression contains function call 8 | # let foo: ssize = f() + 1; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-decl-constant-identifier-is-not-a-constant.test.sunder: -------------------------------------------------------------------------------- 1 | var x: ssize = 123s; 2 | let y: ssize = x; 3 | ################################################################################ 4 | # [error-decl-constant-identifier-is-not-a-constant.test.sunder:2] error: identifier `x` is not a constant 5 | # let y: ssize = x; 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-decl-constant-type-unsized-automatic-type-deduction.test.sunder: -------------------------------------------------------------------------------- 1 | let x = 123; 2 | ################################################################################ 3 | # [error-decl-constant-type-unsized-automatic-type-deduction.test.sunder:1] error: declaration of constant with unsized type `integer` 4 | # let x = 123; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-decl-constant-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | let x: typeof(123) = 123; 2 | ################################################################################ 3 | # [error-decl-constant-type-unsized.test.sunder:1] error: declaration of constant with unsized type `integer` 4 | # let x: typeof(123) = 123; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-decl-constant-uninit-use.test.sunder: -------------------------------------------------------------------------------- 1 | let a: ssize = 123; 2 | let b: ssize = uninit; 3 | let c = a + b; 4 | ################################################################################ 5 | # [error-decl-constant-uninit-use.test.sunder:3] error: constant `b` of type `ssize` is uninitialized 6 | # let c = a + b; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-decl-constant-uninit-without-type.test.sunder: -------------------------------------------------------------------------------- 1 | let x = uninit; 2 | ################################################################################ 3 | # [error-decl-constant-uninit-without-type.test.sunder:1] error: uninitialized constant `x` requires a type specifier 4 | # let x = uninit; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-decl-enum-duplicate-value.test.sunder: -------------------------------------------------------------------------------- 1 | enum foo { 2 | BAR; 3 | BAR; 4 | } 5 | ################################################################################ 6 | # [error-decl-enum-duplicate-value.test.sunder:3] error: duplicate definition of enum value `BAR` 7 | # BAR; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-decl-enum-value-not-an-integer.test.sunder: -------------------------------------------------------------------------------- 1 | enum foo { 2 | BAR = "ABC"; 3 | } 4 | ################################################################################ 5 | # [error-decl-enum-value-not-an-integer.test.sunder:2] error: enum value with type `[]byte` is not an integer 6 | # BAR = "ABC"; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-decl-enum-value-out-of-range-gt-max.test.sunder: -------------------------------------------------------------------------------- 1 | enum foo { 2 | BAR = +0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA; 3 | } 4 | ################################################################################ 5 | # [error-decl-enum-value-out-of-range-gt-max.test.sunder:2] error: out-of-range enum value for underlying type `s32` (226854911280625642308916404954512140970 > 2147483647) 6 | # BAR = +0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-decl-enum-value-out-of-range-lt-min.test.sunder: -------------------------------------------------------------------------------- 1 | enum foo { 2 | BAR = -0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA; 3 | } 4 | ################################################################################ 5 | # [error-decl-enum-value-out-of-range-lt-min.test.sunder:2] error: out-of-range enum value for underlying type `s32` (-226854911280625642308916404954512140970 < -2147483648) 6 | # BAR = -0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-decl-extend-not-a-constant-or-function.test.sunder: -------------------------------------------------------------------------------- 1 | extend u16 struct foo { } 2 | ################################################################################ 3 | # [error-decl-extend-not-a-constant-or-function.test.sunder:1] error: type extension declaration must be a constant or function 4 | # extend u16 struct foo { } 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-decl-extern-var-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | extern var foo: typeof(123); 2 | ################################################################################ 3 | # [error-decl-extern-var-type-unsized.test.sunder:1] error: declaration of extern variable with unsized type `integer` 4 | # extern var foo: typeof(123); 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-decl-variable-type-unsized-automatic-type-deduction.test.sunder: -------------------------------------------------------------------------------- 1 | var x = 123; 2 | ################################################################################ 3 | # [error-decl-variable-type-unsized-automatic-type-deduction.test.sunder:1] error: declaration of variable with unsized type `integer` 4 | # var x = 123; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-decl-variable-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | var x: typeof(123) = 123; 2 | ################################################################################ 3 | # [error-decl-variable-type-unsized.test.sunder:1] error: declaration of variable with unsized type `integer` 4 | # var x: typeof(123) = 123; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-decl-variable-uninit-without-type.test.sunder: -------------------------------------------------------------------------------- 1 | var x = uninit; 2 | ################################################################################ 3 | # [error-decl-variable-uninit-without-type.test.sunder:1] error: uninitialized variable `x` requires a type specifier 4 | # var x = uninit; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-dereference-non-pointer-type-postfix.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: ssize; 3 | } 4 | 5 | func main() void { 6 | var f = (:foo){.x = 123}; 7 | var g = &f; 8 | g.*.x.*; 9 | } 10 | ################################################################################ 11 | # [error-dereference-non-pointer-type-postfix.test.sunder:8] error: cannot dereference non-pointer type `ssize` 12 | # g.*.x.*; 13 | # ^ 14 | -------------------------------------------------------------------------------- /tests/error-dereference-non-pointer-type-prefix.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: ssize; 3 | } 4 | 5 | func main() void { 6 | var f = (:foo){.x = 123}; 7 | var g = &f; 8 | *g.*.x; 9 | } 10 | ################################################################################ 11 | # [error-dereference-non-pointer-type-prefix.test.sunder:8] error: cannot dereference non-pointer type `ssize` 12 | # *g.*.x; 13 | # ^ 14 | -------------------------------------------------------------------------------- /tests/error-duplicate-global-name.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = bar; 2 | let bar: ssize = 1s; 3 | let foo: ssize = 0u; 4 | ################################################################################ 5 | # [error-duplicate-global-name.test.sunder:3] error: redeclaration of `foo` previously declared at [error-duplicate-global-name.test.sunder:1] 6 | # let foo: ssize = 0u; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-duplicate-parameter-name.test.sunder: -------------------------------------------------------------------------------- 1 | func foo( 2 | bar: ssize, # bar on line 2 3 | bar: usize # bar on line 3 4 | ) ssize { 5 | return 1s; 6 | } 7 | ################################################################################ 8 | # [error-duplicate-parameter-name.test.sunder:3] error: redeclaration of `bar` previously declared at [error-duplicate-parameter-name.test.sunder:2] 9 | # bar: usize # bar on line 3 10 | # ^ 11 | -------------------------------------------------------------------------------- /tests/error-expr-access-dot-member-constant-as-value.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: usize; 3 | 4 | let c: u16 = 123; 5 | } 6 | 7 | func main() void { 8 | var f: foo = (:foo){.x = 123}; 9 | f.x; 10 | f.c; 11 | } 12 | ################################################################################ 13 | # [error-expr-access-dot-member-constant-as-value.test.sunder:10] error: attempted to take the value of member constant `c` on type `foo` 14 | # f.c; 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-expr-access-dot-member-function-as-value.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: usize; 3 | 4 | func fn(self: *foo) usize { 5 | return self.*.x; 6 | } 7 | } 8 | 9 | func main() void { 10 | var f: foo = (:foo){.x = 123}; 11 | f.x; 12 | f.fn; 13 | } 14 | ################################################################################ 15 | # [error-expr-access-dot-member-function-as-value.test.sunder:12] error: attempted to take the value of member function `fn` on type `foo` 16 | # f.fn; 17 | # ^ 18 | -------------------------------------------------------------------------------- /tests/error-expr-access-dot-member-not-in-type.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u16; 3 | var y: u16; 4 | } 5 | 6 | func main() void { 7 | var f: foo = (:foo){.x = 123, .y = 456}; 8 | f.x; 9 | f.y; 10 | f.z; 11 | } 12 | ################################################################################ 13 | # [error-expr-access-dot-member-not-in-type.test.sunder:10] error: type `foo` has no member `z` 14 | # f.z; 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-expr-access-dot-member-template-as-value.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: usize; 3 | 4 | func fn[[T]](self: *foo) usize { 5 | return (:T)self.*.x; 6 | } 7 | } 8 | 9 | func main() void { 10 | var f: foo = (:foo){.x = 123}; 11 | f.x; 12 | f.fn; 13 | } 14 | ################################################################################ 15 | # [error-expr-access-dot-member-template-as-value.test.sunder:12] error: attempted to take the value of member template `fn` on type `foo` 16 | # f.fn; 17 | # ^ 18 | -------------------------------------------------------------------------------- /tests/error-expr-access-dot-member-variable-with-template-instantiation.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var value: u32; 3 | } 4 | 5 | func main() void { 6 | var x = (:foo){.value = 0xDEADBEEF}; 7 | x.value[[usize]]; 8 | } 9 | ################################################################################ 10 | # [error-expr-access-dot-member-variable-with-template-instantiation.test.sunder:7] error: attempted template instantiation of member variable `value` on type `foo` 11 | # x.value[[usize]]; 12 | # ^ 13 | -------------------------------------------------------------------------------- /tests/error-expr-access-dot-non-struct-non-union-lhs.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | 1u16.x; 3 | } 4 | ################################################################################ 5 | # [error-expr-access-dot-non-struct-non-union-lhs.test.sunder:2] error: attempted member access on non-struct and non-union type `u16` 6 | # 1u16.x; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-access-index-array-lvalue-out-of-bounds-var.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3u]ssize)[1, 3, 5]; 3 | a[3] = 123; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-index-array-rvalue-out-of-bounds-let.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let a: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | let x: ssize = a[123u]; 4 | } 5 | ################################################################################ 6 | # [error-expr-access-index-array-rvalue-out-of-bounds-let.test.sunder:3] error: index out-of-bounds (array count is 3, received 123) 7 | # let x: ssize = a[123u]; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-access-index-array-rvalue-out-of-bounds-var.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:[3]ssize)[1, 3, 5][3]; 3 | } 4 | ################################################################################ 5 | # fatal: index out-of-bounds 6 | -------------------------------------------------------------------------------- /tests/error-expr-access-index-lhs-slice-in-constant-expr.test.sunder: -------------------------------------------------------------------------------- 1 | let array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 2 | let slice: []ssize = (:[]ssize){&array[1u], 2u}; 3 | let x: ssize = slice[1u]; 4 | ################################################################################ 5 | # [error-expr-access-index-lhs-slice-in-constant-expr.test.sunder:3] error: indexing with left-hand-type `[]ssize` not supported in compile-time expressions 6 | # let x: ssize = slice[1u]; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-access-index-lhs-slice-lvalue-in-constant-expr.test.sunder: -------------------------------------------------------------------------------- 1 | let x = &"foobar"[0]; 2 | ################################################################################ 3 | # [error-expr-access-index-lhs-slice-lvalue-in-constant-expr.test.sunder:1] error: constant expression contains lvalue slice indexing operation 4 | # let x = &"foobar"[0]; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-access-index-lhs-slice-lvalue-out-of-bounds.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | var s = (:[]ssize){&a[0], 3}; 4 | s[3] = 123s; 5 | } 6 | ################################################################################ 7 | # fatal: index out-of-bounds 8 | -------------------------------------------------------------------------------- /tests/error-expr-access-index-lhs-slice-rvalue-out-of-bounds.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | (:[]ssize){&a[0], 3}[3]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-array-lvalue-begin-out-of-bounds-let.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let a = (:[3]ssize)[1, 3, 5]; 3 | a[4:4]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-array-lvalue-begin-out-of-bounds-var.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | a[3:4]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-array-lvalue-end-lt-begin-out-of-bounds-let.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let a = (:[3]ssize)[1, 3, 5]; 3 | a[2:1]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-array-lvalue-end-lt-begin-out-of-bounds-var.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | a[2:1]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-array-lvalue-end-out-of-bounds-let.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let a = (:[3]ssize)[1, 3, 5]; 3 | a[1:4]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-array-lvalue-end-out-of-bounds-var.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | a[1:4]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-invalid-begin-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: [3u]u16 = (:[3u]u16)[0xAAAAu16, 0xBBBBu16, 0xCCCCu16]; 3 | a[1s:3u]; 4 | } 5 | ################################################################################ 6 | # [error-expr-access-slice-invalid-begin-type.test.sunder:3] error: illegal slice operation with index of non-usize type `ssize` 7 | # a[1s:3u]; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-invalid-end-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: [3u]u16 = (:[3u]u16)[0xAAAAu16, 0xBBBBu16, 0xCCCCu16]; 3 | a[1u:3s]; 4 | } 5 | ################################################################################ 6 | # [error-expr-access-slice-invalid-end-type.test.sunder:3] error: illegal slice operation with index of non-usize type `ssize` 7 | # a[1u:3s]; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-invalid-lhs-rvalue-array.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:[3u]u16)[0xAAAAu16, 0xBBBBu16, 0xCCCu16][1u:3u]; 3 | } 4 | ################################################################################ 5 | # [error-expr-access-slice-invalid-lhs-rvalue-array.test.sunder:2] error: left hand side of slice operation is an rvalue array 6 | # (:[3u]u16)[0xAAAAu16, 0xBBBBu16, 0xCCCu16][1u:3u]; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-invalid-lhs-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u16 = 123u16; 3 | a[0u:1u]; 4 | } 5 | ################################################################################ 6 | # [error-expr-access-slice-invalid-lhs-type.test.sunder:3] error: illegal slice operation with left-hand-side of type `u16` 7 | # a[0u:1u]; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-lhs-slice-in-constant-expr.test.sunder: -------------------------------------------------------------------------------- 1 | let array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 2 | let slice: []ssize = (:[]ssize){&array[1u], 2u}; 3 | let x: []ssize = slice[0u:1u]; 4 | ################################################################################ 5 | # [error-expr-access-slice-lhs-slice-in-constant-expr.test.sunder:3] error: slicing with left-hand-type `[]ssize` not supported in compile-time expressions 6 | # let x: []ssize = slice[0u:1u]; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-lhs-slice-lvalue-begin-out-of-bounds.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | var s = (:[]ssize){&a[0], 3}; 4 | s[4:4]; 5 | } 6 | ################################################################################ 7 | # fatal: index out-of-bounds 8 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-lhs-slice-lvalue-end-lt-begin-out-of-bounds.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | var s = (:[]ssize){&a[0], 3}; 4 | s[2:1]; 5 | } 6 | ################################################################################ 7 | # fatal: index out-of-bounds 8 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-lhs-slice-lvalue-end-out-of-bounds.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | var s = (:[]ssize){&a[0], 3}; 4 | s[1:4]; 5 | } 6 | ################################################################################ 7 | # fatal: index out-of-bounds 8 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-lhs-slice-rvalue-begin-out-of-bounds.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | (:[]ssize){&a[0], 3}[4:4]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-lhs-slice-rvalue-end-lt-begin-out-of-bounds.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | (:[]ssize){&a[0], 3}[2:1]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-access-slice-lhs-slice-rvalue-end-out-of-bounds.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a = (:[3]ssize)[1, 3, 5]; 3 | (:[]ssize){&a[0], 3}[1:4]; 4 | } 5 | ################################################################################ 6 | # fatal: index out-of-bounds 7 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-constant.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let x: s8 = 127s8 + 1s8; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-add-integer-out-of-range-constant.test.sunder:2] error: operation produces out-of-range result (127 + 1 == 128) 6 | # let x: s8 = 127s8 + 1s8; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-s16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s16 = 0x7FFFs16; 3 | var b: s16 = 1s16; 4 | a + b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-s32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s32 = 0x7FFFFFFFs32; 3 | var b: s32 = 1s32; 4 | a + b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-s64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s64 = 0x7FFFFFFFFFFFFFFFs64; 3 | var b: s64 = 1s64; 4 | a + b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-s8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s8 = 0x7Fs8; 3 | var b: s8 = 1s8; 4 | a + b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-u16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u16 = 0xFFFFu16; 3 | var b: u16 = 1u16; 4 | a + b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-u32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u32 = 0xFFFFFFFFu32; 3 | var b: u32 = 1u32; 4 | a + b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-u64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u64 = 0xFFFFFFFFFFFFFFFFu64; 3 | var b: u64 = 1u64; 4 | a + b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-add-integer-out-of-range-u8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u8 = 0xFFu8; 3 | var b: u8 = 1u8; 4 | a + b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-arithmetic-incompatible-types.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = 1s + 2u; 2 | ################################################################################ 3 | # [error-expr-binary-arithmetic-incompatible-types.test.sunder:1] error: invalid arguments of types `ssize` and `usize` in binary `+` expression 4 | # let foo: ssize = 1s + 2u; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-binary-arithmetic-invalid-xhs.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = 1s + true; 2 | ################################################################################ 3 | # [error-expr-binary-arithmetic-invalid-xhs.test.sunder:1] error: invalid arguments of types `ssize` and `bool` in binary `+` expression 4 | # let foo: ssize = 1s + true; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-binary-bitwise-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | 1 & 2; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-bitwise-type-unsized.test.sunder:2] error: unsized types `integer` in binary `&` expression have no bit-representation 6 | # 1 & 2; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-constant-integer.test.sunder: -------------------------------------------------------------------------------- 1 | let x = 123s / 0s; 2 | ################################################################################ 3 | # [error-expr-binary-div-divide-by-zero-constant-integer.test.sunder:1] error: divide by zero (123 / 0) 4 | # let x = 123s / 0s; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-s16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s16 = 1s16; 3 | var b: s16 = 0s16; 4 | a / b; 5 | } 6 | ################################################################################ 7 | # fatal: divide by zero 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-s32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s32 = 1s32; 3 | var b: s32 = 0s32; 4 | a / b; 5 | } 6 | ################################################################################ 7 | # fatal: divide by zero 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-s64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s64 = 1s64; 3 | var b: s64 = 0s64; 4 | a / b; 5 | } 6 | ################################################################################ 7 | # fatal: divide by zero 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-s8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s8 = 1s8; 3 | var b: s8 = 0s8; 4 | a / b; 5 | } 6 | ################################################################################ 7 | # fatal: divide by zero 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-u16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u16 = 1u16; 3 | var b: u16 = 0u16; 4 | a / b; 5 | } 6 | ################################################################################ 7 | # fatal: divide by zero 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-u32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u32 = 1u32; 3 | var b: u32 = 0u32; 4 | a / b; 5 | } 6 | ################################################################################ 7 | # fatal: divide by zero 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-u64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u64 = 1u64; 3 | var b: u64 = 0u64; 4 | a / b; 5 | } 6 | ################################################################################ 7 | # fatal: divide by zero 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-div-divide-by-zero-u8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u8 = 1u8; 3 | var b: u8 = 0u8; 4 | a / b; 5 | } 6 | ################################################################################ 7 | # fatal: divide by zero 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-eq-array.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | array == array; 4 | } 5 | ################################################################################ 6 | # [error-expr-binary-eq-array.test.sunder:3] error: invalid arguments of type `[3]ssize` in binary `==` expression 7 | # array == array; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-binary-eq-slice.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | var slice: []ssize = (:[]ssize){&array[0u], 3u}; 4 | slice == slice; 5 | } 6 | ################################################################################ 7 | # [error-expr-binary-eq-slice.test.sunder:4] error: invalid arguments of type `[]ssize` in binary `==` expression 8 | # slice == slice; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-binary-eq-void.test.sunder: -------------------------------------------------------------------------------- 1 | func v() void { 2 | # nothing 3 | } 4 | 5 | func main() void { 6 | v() == v(); 7 | } 8 | ################################################################################ 9 | # [error-expr-binary-eq-void.test.sunder:6] error: invalid arguments of type `void` in binary `==` expression 10 | # v() == v(); 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-expr-binary-ge-array.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | array >= array; 4 | } 5 | ################################################################################ 6 | # [error-expr-binary-ge-array.test.sunder:3] error: invalid arguments of type `[3]ssize` in binary `>=` expression 7 | # array >= array; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-binary-ge-function.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() void { 2 | # nothing 3 | } 4 | func bar() void { 5 | # nothing 6 | } 7 | 8 | func main() void { 9 | foo >= bar; 10 | } 11 | ################################################################################ 12 | # [error-expr-binary-ge-function.test.sunder:9] error: invalid arguments of type `func() void` in binary `>=` expression 13 | # foo >= bar; 14 | # ^ 15 | -------------------------------------------------------------------------------- /tests/error-expr-binary-ge-slice.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | var slice: []ssize = (:[]ssize){&array[0u], 3u}; 4 | slice >= slice; 5 | } 6 | ################################################################################ 7 | # [error-expr-binary-ge-slice.test.sunder:4] error: invalid arguments of type `[]ssize` in binary `>=` expression 8 | # slice >= slice; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-binary-ge-void.test.sunder: -------------------------------------------------------------------------------- 1 | func v() void { 2 | # nothing 3 | } 4 | 5 | func main() void { 6 | v() >= v(); 7 | } 8 | ################################################################################ 9 | # [error-expr-binary-ge-void.test.sunder:6] error: invalid arguments of type `void` in binary `>=` expression 10 | # v() >= v(); 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-expr-binary-gt-array.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | array > array; 4 | } 5 | ################################################################################ 6 | # [error-expr-binary-gt-array.test.sunder:3] error: invalid arguments of type `[3]ssize` in binary `>` expression 7 | # array > array; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-binary-gt-function.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() void { 2 | # nothing 3 | } 4 | func bar() void { 5 | # nothing 6 | } 7 | 8 | func main() void { 9 | foo > bar; 10 | } 11 | ################################################################################ 12 | # [error-expr-binary-gt-function.test.sunder:9] error: invalid arguments of type `func() void` in binary `>` expression 13 | # foo > bar; 14 | # ^ 15 | -------------------------------------------------------------------------------- /tests/error-expr-binary-gt-slice.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | var slice: []ssize = (:[]ssize){&array[0u], 3u}; 4 | slice > slice; 5 | } 6 | ################################################################################ 7 | # [error-expr-binary-gt-slice.test.sunder:4] error: invalid arguments of type `[]ssize` in binary `>` expression 8 | # slice > slice; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-binary-gt-void.test.sunder: -------------------------------------------------------------------------------- 1 | func v() void { 2 | # nothing 3 | } 4 | 5 | func main() void { 6 | v() > v(); 7 | } 8 | ################################################################################ 9 | # [error-expr-binary-gt-void.test.sunder:6] error: invalid arguments of type `void` in binary `>` expression 10 | # v() > v(); 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-expr-binary-le-array.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | array <= array; 4 | } 5 | ################################################################################ 6 | # [error-expr-binary-le-array.test.sunder:3] error: invalid arguments of type `[3]ssize` in binary `<=` expression 7 | # array <= array; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-binary-le-function.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() void { 2 | # nothing 3 | } 4 | func bar() void { 5 | # nothing 6 | } 7 | 8 | func main() void { 9 | foo <= bar; 10 | } 11 | ################################################################################ 12 | # [error-expr-binary-le-function.test.sunder:9] error: invalid arguments of type `func() void` in binary `<=` expression 13 | # foo <= bar; 14 | # ^ 15 | -------------------------------------------------------------------------------- /tests/error-expr-binary-le-slice.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | var slice: []ssize = (:[]ssize){&array[0u], 3u}; 4 | slice <= slice; 5 | } 6 | ################################################################################ 7 | # [error-expr-binary-le-slice.test.sunder:4] error: invalid arguments of type `[]ssize` in binary `<=` expression 8 | # slice <= slice; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-binary-le-void.test.sunder: -------------------------------------------------------------------------------- 1 | func v() void { 2 | # nothing 3 | } 4 | 5 | func main() void { 6 | v() <= v(); 7 | } 8 | ################################################################################ 9 | # [error-expr-binary-le-void.test.sunder:6] error: invalid arguments of type `void` in binary `<=` expression 10 | # v() <= v(); 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-expr-binary-lt-array.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | array < array; 4 | } 5 | ################################################################################ 6 | # [error-expr-binary-lt-array.test.sunder:3] error: invalid arguments of type `[3]ssize` in binary `<` expression 7 | # array < array; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-binary-lt-function.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() void { 2 | # nothing 3 | } 4 | func bar() void { 5 | # nothing 6 | } 7 | 8 | func main() void { 9 | foo < bar; 10 | } 11 | ################################################################################ 12 | # [error-expr-binary-lt-function.test.sunder:9] error: invalid arguments of type `func() void` in binary `<` expression 13 | # foo < bar; 14 | # ^ 15 | -------------------------------------------------------------------------------- /tests/error-expr-binary-lt-slice.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | var slice: []ssize = (:[]ssize){&array[0u], 3u}; 4 | slice < slice; 5 | } 6 | ################################################################################ 7 | # [error-expr-binary-lt-slice.test.sunder:4] error: invalid arguments of type `[]ssize` in binary `<` expression 8 | # slice < slice; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-binary-lt-void.test.sunder: -------------------------------------------------------------------------------- 1 | func v() void { 2 | # nothing 3 | } 4 | 5 | func main() void { 6 | v() < v(); 7 | } 8 | ################################################################################ 9 | # [error-expr-binary-lt-void.test.sunder:6] error: invalid arguments of type `void` in binary `<` expression 10 | # v() < v(); 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-constant.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let x: s8 = 127s8 * 2s8; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-mul-integer-out-of-range-constant.test.sunder:2] error: operation produces out-of-range result (127 * 2 == 254) 6 | # let x: s8 = 127s8 * 2s8; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-s16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s16 = 0x7FFFs16; 3 | var b: s16 = 2s16; 4 | a * b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-s32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s32 = 0x7FFFFFFFs32; 3 | var b: s32 = 2s32; 4 | a * b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-s64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s64 = 0x7FFFFFFFFFFFFFFFs64; 3 | var b: s64 = 2s64; 4 | a * b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-s8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s8 = 0x7Fs8; 3 | var b: s8 = 2s8; 4 | a * b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-u16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u16 = 0xFFFFu16; 3 | var b: u16 = 2u16; 4 | a * b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-u32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u32 = 0xFFFFFFFFu32; 3 | var b: u32 = 2u32; 4 | a * b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-u64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u64 = 0xFFFFFFFFFFFFFFFFu64; 3 | var b: u64 = 2u64; 4 | a * b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-mul-integer-out-of-range-u8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u8 = 0xFFu8; 3 | var b: u8 = 2u8; 4 | a * b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-ne-array.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | array != array; 4 | } 5 | ################################################################################ 6 | # [error-expr-binary-ne-array.test.sunder:3] error: invalid arguments of type `[3]ssize` in binary `!=` expression 7 | # array != array; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-binary-ne-slice.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var array: [3u]ssize = (:[3u]ssize)[1s, 3s, 5s]; 3 | var slice: []ssize = (:[]ssize){&array[0u], 3u}; 4 | slice != slice; 5 | } 6 | ################################################################################ 7 | # [error-expr-binary-ne-slice.test.sunder:4] error: invalid arguments of type `[]ssize` in binary `!=` expression 8 | # slice != slice; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-binary-ne-void.test.sunder: -------------------------------------------------------------------------------- 1 | func v() void { 2 | # nothing 3 | } 4 | 5 | func main() void { 6 | v() != v(); 7 | } 8 | ################################################################################ 9 | # [error-expr-binary-ne-void.test.sunder:6] error: invalid arguments of type `void` in binary `!=` expression 10 | # v() != v(); 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-expr-binary-shift-with-non-integer-lhs.test.sunder: -------------------------------------------------------------------------------- 1 | let x = true << 1u; 2 | ################################################################################ 3 | # [error-expr-binary-shift-with-non-integer-lhs.test.sunder:1] error: invalid left-hand argument of type `bool` in binary `<<` expression 4 | # let x = true << 1u; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-binary-shift-with-non-usize-rhs.test.sunder: -------------------------------------------------------------------------------- 1 | let x = 1s << 1s; 2 | ################################################################################ 3 | # [error-expr-binary-shift-with-non-usize-rhs.test.sunder:1] error: invalid non-usize right-hand argument of type `ssize` in binary `<<` expression 4 | # let x = 1s << 1s; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-binary-shiftl-with-unsized-lhs.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: usize = 1 << 2; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-shiftl-with-unsized-lhs.test.sunder:2] error: unsized type `integer` in binary `<<` expression has no bit-representation 6 | # var x: usize = 1 << 2; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-shiftr-with-unsized-lhs.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: usize = 1 >> 2; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-shiftr-with-unsized-lhs.test.sunder:2] error: unsized type `integer` in binary `>>` expression has no bit-representation 6 | # var x: usize = 1 >> 2; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-constant.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let x: s8 = -128s8 - 1s8; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-sub-integer-out-of-range-constant.test.sunder:2] error: operation produces out-of-range result (-128 - 1 == -129) 6 | # let x: s8 = -128s8 - 1s8; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-s16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s16 = -32768s16; 3 | var b: s16 = 1s16; 4 | a - b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-s32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s32 = -2147483648s32; 3 | var b: s32 = 1s32; 4 | a - b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-s64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s64 = -9223372036854775808s64; 3 | var b: s64 = 1s64; 4 | a - b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-s8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: s8 = -128s8; 3 | var b: s8 = 1s8; 4 | a - b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-u16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u16 = 0u16; 3 | var b: u16 = 1u16; 4 | a - b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-u32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u32 = 0u32; 3 | var b: u32 = 1u32; 4 | a - b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-u64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u64 = 0u64; 3 | var b: u64 = 1u64; 4 | a - b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-sub-integer-out-of-range-u8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var a: u8 = 0u8; 3 | var b: u8 = 1u8; 4 | a - b; 5 | } 6 | ################################################################################ 7 | # fatal: operation produces out-of-range result 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-wrapping-add-with-unsized-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let x = 1 +% 1; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-wrapping-add-with-unsized-type.test.sunder:2] error: invalid arguments of type `integer` in wrapping binary `+%` expression 6 | # let x = 1 +% 1; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-wrapping-mul-with-unsized-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let x = 1 *% 1; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-wrapping-mul-with-unsized-type.test.sunder:2] error: invalid arguments of type `integer` in wrapping binary `*%` expression 6 | # let x = 1 *% 1; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-binary-wrapping-sub-with-unsized-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let x = 1 -% 1; 3 | } 4 | ################################################################################ 5 | # [error-expr-binary-wrapping-sub-with-unsized-type.test.sunder:2] error: invalid arguments of type `integer` in wrapping binary `-%` expression 6 | # let x = 1 -% 1; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-function-invalid-argument-count.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u16; 3 | 4 | func fn(self_: *foo, p_: usize, q_: ssize) void { 5 | } 6 | } 7 | 8 | func main() void { 9 | var f: foo = (:foo){.x = 123}; 10 | f.fn(123u); 11 | } 12 | ################################################################################ 13 | # [error-expr-call-member-function-invalid-argument-count.test.sunder:10] error: member function with type `func(*foo, usize, ssize) void` expects 2 argument(s) (1 provided) 14 | # f.fn(123u); 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-function-invalid-argument-type.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u16; 3 | 4 | func fn(self_: *foo, p_: usize, q_: ssize) void { 5 | } 6 | } 7 | 8 | func main() void { 9 | var f: foo = (:foo){.x = 123}; 10 | f.fn( 11 | 123u, # valid 12 | 456u # invalid (should be ssize) 13 | ); 14 | } 15 | ################################################################################ 16 | # [error-expr-call-member-function-invalid-argument-type.test.sunder:12] error: incompatible argument type `usize` (expected `ssize`) 17 | # 456u # invalid (should be ssize) 18 | # ^ 19 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-function-no-self-parameter-function-has-non-zero-number-of-parameters.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u16; 3 | var y: u16; 4 | 5 | func fn(p_: usize, q_: ssize) void { 6 | } 7 | } 8 | 9 | func main() void { 10 | var a: foo = (:foo){.x = 123, .y = 456}; 11 | a.fn(); 12 | } 13 | ################################################################################ 14 | # [error-expr-call-member-function-no-self-parameter-function-has-non-zero-number-of-parameters.test.sunder:11] error: expected type `*foo` for the first parameter of member function `fn` of type `foo` (found `usize`) 15 | # a.fn(); 16 | # ^ 17 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-function-no-self-parameter-function-has-zero-number-of-parameters.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u16; 3 | var y: u16; 4 | 5 | func fn() void { 6 | } 7 | } 8 | 9 | func main() void { 10 | var a: foo = (:foo){.x = 123, .y = 456}; 11 | a.fn(); 12 | } 13 | ################################################################################ 14 | # [error-expr-call-member-function-no-self-parameter-function-has-zero-number-of-parameters.test.sunder:11] error: expected type `*foo` for the first parameter of member function `fn` of type `foo` 15 | # a.fn(); 16 | # ^ 17 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-function-no-template-instantiation.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var value: u32; 3 | 4 | func as[[T]](self: *foo) T { 5 | return (:T)self.*.value; 6 | } 7 | } 8 | 9 | func main() void { 10 | var x = (:foo){.value = 0xDEADBEEF}; 11 | x.as(); 12 | } 13 | ################################################################################ 14 | # [error-expr-call-member-function-no-template-instantiation.test.sunder:11] error: template instantiation of `as` requires a template argument list 15 | # x.as(); 16 | # ^ 17 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-function-not-in-struct.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u16; 3 | var y: u16; 4 | } 5 | 6 | func main() void { 7 | var f: foo = (:foo){.x = 123, .y = 456}; 8 | f.z(); 9 | } 10 | ################################################################################ 11 | # [error-expr-call-member-function-not-in-struct.test.sunder:8] error: type `foo` has no member function `z` 12 | # f.z(); 13 | # ^ 14 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-function-type-has-no-member-function-nested-type.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: usize; 3 | } 4 | 5 | struct bar { 6 | var f: foo; 7 | } 8 | 9 | func main() void { 10 | var f = (:foo){.x = 123}; 11 | var b = (:bar){.f = f}; 12 | b.f.fn(); 13 | } 14 | ################################################################################ 15 | # [error-expr-call-member-function-type-has-no-member-function-nested-type.test.sunder:12] error: type `foo` has no member function `fn` 16 | # b.f.fn(); 17 | # ^ 18 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-function-type-has-no-member-function.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: usize; 3 | } 4 | 5 | func main() void { 6 | var f = (:foo){.x = 123}; 7 | f.fn(); 8 | } 9 | ################################################################################ 10 | # [error-expr-call-member-function-type-has-no-member-function.test.sunder:7] error: type `foo` has no member function `fn` 11 | # f.fn(); 12 | # ^ 13 | -------------------------------------------------------------------------------- /tests/error-expr-call-member-variable-function-with-template-instantiation.test.sunder: -------------------------------------------------------------------------------- 1 | func usize_to_ssize(val: usize) ssize { 2 | return (:ssize)val; 3 | } 4 | struct foo { 5 | var function: func(usize) ssize; 6 | } 7 | 8 | func main() void { 9 | var x = (:foo){.function = usize_to_ssize}; 10 | x.function[[u16]](123); 11 | } 12 | ################################################################################ 13 | # [error-expr-call-member-variable-function-with-template-instantiation.test.sunder:10] error: attempted template instantiation of member variable `function` on type `foo` 14 | # x.function[[u16]](123); 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-expr-cast-constant-from-pointer.test.sunder: -------------------------------------------------------------------------------- 1 | let x: byte = 0xFFy; 2 | let y: usize = (:usize)&x; 3 | ################################################################################ 4 | # [error-expr-cast-constant-from-pointer.test.sunder:2] error: constant expression contains cast from pointer type `*byte` to non-pointer type `usize` 5 | # let y: usize = (:usize)&x; 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-f32-to-integer-out-of-range-in-constant-expression.test.sunder: -------------------------------------------------------------------------------- 1 | let x = (:s8)500.0f32; 2 | ################################################################################ 3 | # [error-expr-cast-from-f32-to-integer-out-of-range-in-constant-expression.test.sunder:1] error: operation produces out-of-range result 4 | # let x = (:s8)500.0f32; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-f32-to-integer-out-of-range.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let a = 256.0f32; 3 | (:u8)a; 4 | } 5 | ################################################################################ 6 | # fatal: operation produces out-of-range result 7 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-f32-to-unsized-integer.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:integer)123.456f32; 3 | } 4 | ################################################################################ 5 | # [error-expr-cast-from-f32-to-unsized-integer.test.sunder:2] error: invalid cast to unsized type `integer` from `f32` 6 | # (:integer)123.456f32; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-f64-to-integer-out-of-range-in-constant-expression.test.sunder: -------------------------------------------------------------------------------- 1 | let x = (:s8)500.0f64; 2 | ################################################################################ 3 | # [error-expr-cast-from-f64-to-integer-out-of-range-in-constant-expression.test.sunder:1] error: operation produces out-of-range result 4 | # let x = (:s8)500.0f64; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-f64-to-integer-out-of-range.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let a = 256.0f64; 3 | (:u8)a; 4 | } 5 | ################################################################################ 6 | # fatal: operation produces out-of-range result 7 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-f64-to-unsized-integer.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:integer)123.456f64; 3 | } 4 | ################################################################################ 5 | # [error-expr-cast-from-f64-to-unsized-integer.test.sunder:2] error: invalid cast to unsized type `integer` from `f64` 6 | # (:integer)123.456f64; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-type-unsized-integer-to-byte-out-of-range.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:byte)123456; 3 | } 4 | ################################################################################ 5 | # [error-expr-cast-from-type-unsized-integer-to-byte-out-of-range.test.sunder:2] error: out-of-range conversion from `integer` to `byte` (123456 > 255) 6 | # (:byte)123456; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-type-unsized-integer-to-sized-integer-out-of-range.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:u8)123456; 3 | } 4 | ################################################################################ 5 | # [error-expr-cast-from-type-unsized-integer-to-sized-integer-out-of-range.test.sunder:2] error: out-of-range conversion from `integer` to `u8` (123456 > 255) 6 | # (:u8)123456; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-unsized-integer-to-f32-out-of-range.test.sunder: -------------------------------------------------------------------------------- 1 | let x = (:f32)0xBEEFBEEF; 2 | ################################################################################ 3 | # [error-expr-cast-from-unsized-integer-to-f32-out-of-range.test.sunder:1] error: constant expression contains cast from integer type `integer` to floating point type `f32` with unrepresentable value 3203383023 4 | # let x = (:f32)0xBEEFBEEF; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-cast-from-unsized-integer-to-f64-out-of-range.test.sunder: -------------------------------------------------------------------------------- 1 | let x = (:f64)0xBEEFBEEFBEEFBEEF; 2 | ################################################################################ 3 | # [error-expr-cast-from-unsized-integer-to-f64-out-of-range.test.sunder:1] error: constant expression contains cast from integer type `integer` to floating point type `f64` with unrepresentable value 13758425323549998831 4 | # let x = (:f64)0xBEEFBEEFBEEFBEEF; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-cast-function-to-function-mismatched-parameter-count.test.sunder: -------------------------------------------------------------------------------- 1 | func f(x: usize, y: ssize) void { } 2 | let g = (:func(usize) void)f; 3 | ################################################################################ 4 | # [error-expr-cast-function-to-function-mismatched-parameter-count.test.sunder:2] error: cannot convert from `func(usize, ssize) void` to `func(usize) void` (mismatched parameter count) 5 | # let g = (:func(usize) void)f; 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-expr-cast-function-to-function-mismatched-parameter-type.test.sunder: -------------------------------------------------------------------------------- 1 | func f(x: usize, y: ssize) void { } 2 | let g = (:func(usize, usize) void)f; 3 | ################################################################################ 4 | # [error-expr-cast-function-to-function-mismatched-parameter-type.test.sunder:2] error: cannot convert from `func(usize, ssize) void` to `func(usize, usize) void` (mismatched parameter types `ssize` and `usize`) 5 | # let g = (:func(usize, usize) void)f; 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-expr-cast-function-to-function-mismatched-return-type.test.sunder: -------------------------------------------------------------------------------- 1 | func f(x: usize, y: ssize) void { } 2 | let g = (:func(usize, ssize) usize)f; 3 | ################################################################################ 4 | # [error-expr-cast-function-to-function-mismatched-return-type.test.sunder:2] error: cannot convert from `func(usize, ssize) void` to `func(usize, ssize) usize` (mismatched return types `void` and `usize`) 5 | # let g = (:func(usize, ssize) usize)f; 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-expr-cast-invalid-cast.test.sunder: -------------------------------------------------------------------------------- 1 | let x: []byte = (:[]byte)0xABCDu16; 2 | ################################################################################ 3 | # [error-expr-cast-invalid-cast.test.sunder:1] error: invalid cast from `u16` to `[]byte` 4 | # let x: []byte = (:[]byte)0xABCDu16; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-cast-to-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:typeof(123456))123456u; 3 | } 4 | ################################################################################ 5 | # [error-expr-cast-to-type-unsized.test.sunder:2] error: invalid cast to unsized type `integer` from `usize` 6 | # (:typeof(123456))123456u; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-init-struct-initializer-wrong-type.test.sunder: -------------------------------------------------------------------------------- 1 | struct s { 2 | var x: u16; 3 | } 4 | 5 | let a = (:s){.x = 123u32}; 6 | ################################################################################ 7 | # [error-expr-init-struct-initializer-wrong-type.test.sunder:5] error: incompatible type `u32` (expected `u16`) 8 | # let a = (:s){.x = 123u32}; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-init-union-expected-one-initializer-got-two.test.sunder: -------------------------------------------------------------------------------- 1 | union u { 2 | var x: usize; 3 | var y: ssize; 4 | } 5 | 6 | let a = (:u){.x = 123, .y = 456}; 7 | ################################################################################ 8 | # [error-expr-init-union-expected-one-initializer-got-two.test.sunder:6] error: union type `u` requires exactly one initializer 9 | # let a = (:u){.x = 123, .y = 456}; 10 | # ^ 11 | -------------------------------------------------------------------------------- /tests/error-expr-init-union-expected-one-initializer-got-zero.test.sunder: -------------------------------------------------------------------------------- 1 | union u { 2 | var x: usize; 3 | } 4 | 5 | let a = (:u){}; 6 | ################################################################################ 7 | # [error-expr-init-union-expected-one-initializer-got-zero.test.sunder:5] error: union type `u` requires exactly one initializer 8 | # let a = (:u){}; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-init-union-expected-zero-initializers-got-one.test.sunder: -------------------------------------------------------------------------------- 1 | union u { 2 | } 3 | 4 | let a = (:u){.x = 123}; 5 | ################################################################################ 6 | # [error-expr-init-union-expected-zero-initializers-got-one.test.sunder:4] error: union type `u` with no members variables requires exactly zero initializers 7 | # let a = (:u){.x = 123}; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-init-union-initializer-wrong-type.test.sunder: -------------------------------------------------------------------------------- 1 | union u { 2 | var x: u16; 3 | } 4 | 5 | let a = (:u){.x = 123u32}; 6 | ################################################################################ 7 | # [error-expr-init-union-initializer-wrong-type.test.sunder:5] error: incompatible type `u32` (expected `u16`) 8 | # let a = (:u){.x = 123u32}; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-expr-invalid-infix-token.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | 123s , 345s; 3 | } 4 | ################################################################################ 5 | # [error-expr-invalid-infix-token.test.sunder:2] error: expected `;`, found `,` 6 | # 123s , 345s; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-invalid-prefix-token.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | ,123s; 3 | } 4 | ################################################################################ 5 | # [error-expr-invalid-prefix-token.test.sunder:2] error: unrecognized prefix token `,` in expression 6 | # ,123s; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-list-not-array-or-slice-type.test.sunder: -------------------------------------------------------------------------------- 1 | let a: [3u]byte = (:ssize)[0xAAy, 0xBBy, 0xCCy]; 2 | ################################################################################ 3 | # [error-expr-list-not-array-or-slice-type.test.sunder:1] error: expected array or slice type (received `ssize`) 4 | # let a: [3u]byte = (:ssize)[0xAAy, 0xBBy, 0xCCy]; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-member-access-union-with-different-value.test.sunder: -------------------------------------------------------------------------------- 1 | union u { 2 | var x: u16; 3 | var y: u32; 4 | } 5 | 6 | let a = (:u){.y = 123}; 7 | let b = a.x; 8 | ################################################################################ 9 | # [error-expr-member-access-union-with-different-value.test.sunder:7] error: attempted access of the member `x` of a union holding a value in member `y` 10 | # let b = a.x; 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-expr-member-access-union-with-no-value.test.sunder: -------------------------------------------------------------------------------- 1 | union u { 2 | var x: u16; 3 | var y: u32; 4 | } 5 | 6 | let a: u = uninit; 7 | let b = a.x; 8 | ################################################################################ 9 | # [error-expr-member-access-union-with-no-value.test.sunder:7] error: constant `a` of type `u` is uninitialized 10 | # let b = a.x; 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-expr-sizeof-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | sizeof(typeof(123)); 3 | } 4 | ################################################################################ 5 | # [error-expr-sizeof-type-unsized.test.sunder:2] error: type `integer` has no defined size 6 | # sizeof(typeof(123)); 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-slice-not-slice-type.test.sunder: -------------------------------------------------------------------------------- 1 | let a: [3u]byte = (:[3u]byte)[0xAAy, 0xBBy, 0xCCy]; 2 | let b: []byte = (:ssize){&a[0u], 3u}; 3 | ################################################################################ 4 | # [error-expr-slice-not-slice-type.test.sunder:2] error: expected slice type (received `ssize`) 5 | # let b: []byte = (:ssize){&a[0u], 3u}; 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-expr-unary-addressof-non-static-object-in-compile-time-expression.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: u32 = 0xDEADBEEFu32; 3 | let px: *u32 = &x; 4 | } 5 | ################################################################################ 6 | # [error-expr-unary-addressof-non-static-object-in-compile-time-expression.test.sunder:3] error: addressof operator applied to non-static object in compile-time expression 7 | # let px: *u32 = &x; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-unary-arithmetic-invalid-rhs.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = +true; 2 | ################################################################################ 3 | # [error-expr-unary-arithmetic-invalid-rhs.test.sunder:1] error: invalid argument of type `bool` in unary `+` expression 4 | # let foo: ssize = +true; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-expr-unary-bitnot-with-unsized-rhs.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: usize = ~1; 3 | } 4 | ################################################################################ 5 | # [error-expr-unary-bitnot-with-unsized-rhs.test.sunder:2] error: unsized type `integer` in unary `~` expression has no bit-representation 6 | # var x: usize = ~1; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-expr-unary-neg-integer-out-of-range-constant.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let x: s8 = -128s8; 3 | let y: s8 = -x; 4 | } 5 | ################################################################################ 6 | # [error-expr-unary-neg-integer-out-of-range-constant.test.sunder:3] error: operation produces out-of-range result (-(-128) == 128) 7 | # let y: s8 = -x; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-unary-neg-integer-out-of-range-s16.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: s16 = -32768s16; 3 | -x; 4 | } 5 | ################################################################################ 6 | # fatal: operation produces out-of-range result 7 | -------------------------------------------------------------------------------- /tests/error-expr-unary-neg-integer-out-of-range-s32.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: s32 = -2147483648s32; 3 | -x; 4 | } 5 | ################################################################################ 6 | # fatal: operation produces out-of-range result 7 | -------------------------------------------------------------------------------- /tests/error-expr-unary-neg-integer-out-of-range-s64.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: s64 = -9223372036854775808s64; 3 | -x; 4 | } 5 | ################################################################################ 6 | # fatal: operation produces out-of-range result 7 | -------------------------------------------------------------------------------- /tests/error-expr-unary-neg-integer-out-of-range-s8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: s8 = -128s8; 3 | -x; 4 | } 5 | ################################################################################ 6 | # fatal: operation produces out-of-range result 7 | -------------------------------------------------------------------------------- /tests/error-expr-unary-neg-uinteger.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: usize = 123u; 3 | -x; 4 | } 5 | ################################################################################ 6 | # [error-expr-unary-neg-uinteger.test.sunder:3] error: invalid argument of type `usize` in unary `-` expression 7 | # -x; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-unary-wrapping-neg-uinteger.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: usize = 123u; 3 | -%x; 4 | } 5 | ################################################################################ 6 | # [error-expr-unary-wrapping-neg-uinteger.test.sunder:3] error: invalid argument of type `usize` in unary `-%` expression 7 | # -%x; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-expr-unary-wrapping-neg-with-unsized-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | let x = -%1; 3 | } 4 | ################################################################################ 5 | # [error-expr-unary-wrapping-neg-with-unsized-type.test.sunder:2] error: invalid argument of type `integer` in wrapping unary `-%` expression 6 | # let x = -%1; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-extend-declaration-before-non-extend-declaration.test.sunder: -------------------------------------------------------------------------------- 1 | extend u16 let MAX: u16 = 0xFFFFu16; 2 | let foo: u16 = 123; 3 | ################################################################################ 4 | # [error-extend-declaration-before-non-extend-declaration.test.sunder:1] error: extend declaration must appear after all module-level declarations 5 | # extend u16 let MAX: u16 = 0xFFFFu16; 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-func-does-not-end-with-a-return-statement-no-stmts.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() bool { 2 | } 3 | 4 | func main() void { 5 | var x = foo(); 6 | } 7 | ################################################################################ 8 | # [error-func-does-not-end-with-a-return-statement-no-stmts.test.sunder:1] error: Non-void-returning function does not end with a return statement 9 | # func foo() bool { 10 | # ^ 11 | -------------------------------------------------------------------------------- /tests/error-func-does-not-end-with-a-return-statement-some-stmts.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() bool { 2 | var _ = true; 3 | } 4 | 5 | func main() void { 6 | var x = foo(); 7 | } 8 | ################################################################################ 9 | # [error-func-does-not-end-with-a-return-statement-some-stmts.test.sunder:1] error: Non-void-returning function does not end with a return statement 10 | # func foo() bool { 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-func-parameter-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | func f(x: typeof(123)) void { 2 | } 3 | ################################################################################ 4 | # [error-func-parameter-type-unsized.test.sunder:1] error: declaration of function parameter with unsized type `integer` 5 | # func f(x: typeof(123)) void { 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-func-return-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | func f() typeof(123) { 2 | return 123; 3 | } 4 | ################################################################################ 5 | # [error-func-return-type-unsized.test.sunder:1] error: declaration of function with unsized return type `integer` 6 | # func f() typeof(123) { 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-identifier-is-not-a-type.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = 1s; 2 | let bar: foo = 2s; 3 | ################################################################################ 4 | # [error-identifier-is-not-a-type.test.sunder:2] error: identifier `foo` is not a type 5 | # let bar: foo = 2s; 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-ieee754-missing-digit-after-decimal-separator.test.sunder: -------------------------------------------------------------------------------- 1 | let x = 123.f32; 2 | ################################################################################ 3 | # [error-ieee754-missing-digit-after-decimal-separator.test.sunder:1] error: floating point literal requires at least one digit after the decimal separator 4 | # let x = 123.f32; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-ieee754-non-decimal-base.test.sunder: -------------------------------------------------------------------------------- 1 | let x = 0x123.0f32; 2 | ################################################################################ 3 | # [error-ieee754-non-decimal-base.test.sunder:1] error: floating point literal has non-decimal base 4 | # let x = 0x123.0f32; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-illegal-for-range-index-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | for i: bool in 100 { 3 | } 4 | } 5 | ################################################################################ 6 | # [error-illegal-for-range-index-type.test.sunder:2] error: illegal for-range index type `bool` 7 | # for i: bool in 100 { 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-illegal-type-conversion-in-assignment.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: ssize = 1s; 3 | var y: usize = 2u; 4 | x = y; 5 | } 6 | ################################################################################ 7 | # [error-illegal-type-conversion-in-assignment.test.sunder:4] error: incompatible type `usize` (expected `ssize`) 8 | # x = y; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-illegal-type-conversion-in-declaration.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: bool = 123s; 2 | ################################################################################ 3 | # [error-illegal-type-conversion-in-declaration.test.sunder:1] error: incompatible type `ssize` (expected `bool`) 4 | # let foo: bool = 123s; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-illegal-type-conversion-of-array-element.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:[3u]u8)[1u8, 2s64, 3u8]; 3 | } 4 | ################################################################################ 5 | # [error-illegal-type-conversion-of-array-element.test.sunder:2] error: incompatible type `s64` (expected `u8`) 6 | # (:[3u]u8)[1u8, 2s64, 3u8]; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-integer-literal-no-digits.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = 0xs; 2 | ################################################################################ 3 | # [error-integer-literal-no-digits.test.sunder:1] error: integer literal has no digits 4 | # let foo: ssize = 0xs; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-integer-literal-out-of-range-gt-max-byte.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | +256y; 3 | } 4 | ################################################################################ 5 | # [error-integer-literal-out-of-range-gt-max-byte.test.sunder:2] error: out-of-range byte (256 > 255) 6 | # +256y; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-integer-literal-out-of-range-gt-max-s8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | +128s8; 3 | } 4 | ################################################################################ 5 | # [error-integer-literal-out-of-range-gt-max-s8.test.sunder:2] error: out-of-range integer (128 > 127) 6 | # +128s8; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-integer-literal-out-of-range-lt-min-byte.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | -1y; 3 | } 4 | ################################################################################ 5 | # [error-integer-literal-out-of-range-lt-min-byte.test.sunder:2] error: out-of-range byte (-1 < 0) 6 | # -1y; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-integer-literal-out-of-range-lt-min-s8.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | -129s8; 3 | } 4 | ################################################################################ 5 | # [error-integer-literal-out-of-range-lt-min-s8.test.sunder:2] error: out-of-range integer (-129 < -128) 6 | # -129s8; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-integer-literal-unknown-suffix.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = 0x123zu; 2 | ################################################################################ 3 | # [error-integer-literal-unknown-suffix.test.sunder:1] error: unknown integer literal suffix `zu` 4 | # let foo: ssize = 0x123zu; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-character.test.sunder: -------------------------------------------------------------------------------- 1 | let a: byte = 'abc'; 2 | ################################################################################ 3 | # [error-invalid-character.test.sunder:1] error: invalid character literal 4 | # let a: byte = 'abc'; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-escape-sequence-bytes-literal.test.sunder: -------------------------------------------------------------------------------- 1 | let a: []byte = "\z"; 2 | ################################################################################ 3 | # [error-invalid-escape-sequence-bytes-literal.test.sunder:1] error: unknown escape sequence 4 | # let a: []byte = "\z"; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-escape-sequence-character-literal.test.sunder: -------------------------------------------------------------------------------- 1 | let a: byte = '\z'; 2 | ################################################################################ 3 | # [error-invalid-escape-sequence-character-literal.test.sunder:1] error: unknown escape sequence 4 | # let a: byte = '\z'; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-escape-sequence-hex-literal-first-digit.test.sunder: -------------------------------------------------------------------------------- 1 | let a: byte = '\xZA'; 2 | ################################################################################ 3 | # [error-invalid-escape-sequence-hex-literal-first-digit.test.sunder:1] error: invalid hexadecimal escape sequence 4 | # let a: byte = '\xZA'; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-escape-sequence-hex-literal-second-digit.test.sunder: -------------------------------------------------------------------------------- 1 | let a: byte = '\xAZ'; 2 | ################################################################################ 3 | # [error-invalid-escape-sequence-hex-literal-second-digit.test.sunder:1] error: invalid hexadecimal escape sequence 4 | # let a: byte = '\xAZ'; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-for-range-begin-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | for i: ssize in 1u:100s { 3 | } 4 | } 5 | ################################################################################ 6 | # [error-invalid-for-range-begin-type.test.sunder:2] error: incompatible type `usize` (expected `ssize`) 7 | # for i: ssize in 1u:100s { 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-invalid-for-range-end-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | for i: ssize in 1s:100u { 3 | } 4 | } 5 | ################################################################################ 6 | # [error-invalid-for-range-end-type.test.sunder:2] error: incompatible type `usize` (expected `ssize`) 7 | # for i: ssize in 1s:100u { 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-invalid-non-printable-character-in-bytes-literal.test.sunder: -------------------------------------------------------------------------------- 1 | let a: []byte = ""; 2 | ################################################################################ 3 | # [error-invalid-non-printable-character-in-bytes-literal.test.sunder:1] error: non-printable byte 0x1b in bytes literal 4 | # let a: []byte = ""; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-non-printable-character-in-character-literal.test.sunder: -------------------------------------------------------------------------------- 1 | let a: byte = ''; 2 | ################################################################################j 3 | # [error-invalid-non-printable-character-in-character-literal.test.sunder:1] error: non-printable byte 0x1b in character literal 4 | # let a: byte = ''; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-sigil.test.sunder: -------------------------------------------------------------------------------- 1 | $%& 2 | ################################################################################ 3 | # [error-invalid-sigil.test.sunder:1] error: invalid token `$%&` 4 | # $%& 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-invalid-stmt-op-assign.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: void = uninit; 3 | x += x; 4 | } 5 | ################################################################################ 6 | # [error-invalid-stmt-op-assign.test.sunder:3] error: invalid arguments of types `void` and `void` in binary `+` expression 7 | # x += x; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-main-invalid-function-signature.test.sunder: -------------------------------------------------------------------------------- 1 | func main(argc_: usize, argv_: **byte) ssize { return 1s; } 2 | ################################################################################ 3 | # [error-main-invalid-function-signature.test.sunder:1] error: main has invalid type `func(usize, **byte) ssize` (expected `func() void`) 4 | # func main(argc_: usize, argv_: **byte) ssize { return 1s; } 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-main-is-not-defined-as-a-function.test.sunder: -------------------------------------------------------------------------------- 1 | let main = 1s; 2 | ################################################################################ 3 | # error: main function is not defined 4 | -------------------------------------------------------------------------------- /tests/error-main-is-not-defined.test.sunder: -------------------------------------------------------------------------------- 1 | # This program does not contain a definition of main. 2 | ################################################################################ 3 | # error: main function is not defined 4 | -------------------------------------------------------------------------------- /tests/error-nested-function-declaration.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | func foo() void { 3 | } 4 | } 5 | ################################################################################ 6 | # [error-nested-function-declaration.test.sunder:2] error: nested function declaration 7 | # func foo() void { 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-null-pointer-dereference.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | *(:*byte)0u; 3 | } 4 | ################################################################################ 5 | # fatal: null pointer dereference 6 | -------------------------------------------------------------------------------- /tests/error-return-expr-in-function-with-void-return.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() void { 2 | return 1s; 3 | } 4 | ################################################################################ 5 | # [error-return-expr-in-function-with-void-return.test.sunder:2] error: incompatible type `ssize` (expected `void`) 6 | # return 1s; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-return-invalid-type.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() ssize { 2 | return 1u; 3 | } 4 | ################################################################################ 5 | # [error-return-invalid-type.test.sunder:2] error: incompatible type `usize` (expected `ssize`) 6 | # return 1u; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-return-void-in-function-with-non-void-return.test.sunder: -------------------------------------------------------------------------------- 1 | func foo() ssize { 2 | return; 3 | } 4 | ################################################################################ 5 | # [error-return-void-in-function-with-non-void-return.test.sunder:2] error: illegal return statement in function with non-void return type 6 | # return; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-shows-fully-qualified-struct-symbol-name.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func foo(arg_: std::optional[[u16]]) void { } 4 | 5 | func main() void { 6 | foo(std::optional[[u32]]::init_empty()); 7 | } 8 | ################################################################################ 9 | # [error-shows-fully-qualified-struct-symbol-name.test.sunder:6] error: incompatible argument type `std::optional[[u32]]` (expected `std::optional[[u16]]`) 10 | # foo(std::optional[[u32]]::init_empty()); 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-slice-list-ellipsis-element.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | (:[]ssize)[123, 456...]; 3 | } 4 | ################################################################################ 5 | # [error-slice-list-ellipsis-element.test.sunder:2] error: ellipsis element is not allowed in slice lists 6 | # (:[]ssize)[123, 456...]; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-stmt-assert-is-not-a-bool.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | assert 123s; 3 | } 4 | ################################################################################ 5 | # [error-stmt-assert-is-not-a-bool.test.sunder:2] error: assert with non-boolean type `ssize` 6 | # assert 123s; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-stmt-assign-incompatible-type.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var x: s64 = 0; 3 | x = 1s32 + 2s32 * 3s32; 4 | } 5 | ################################################################################ 6 | # [error-stmt-assign-incompatible-type.test.sunder:3] error: incompatible type `s32` (expected `s64`) 7 | # x = 1s32 + 2s32 * 3s32; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-stmt-break-outside-of-loop.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | break; 3 | } 4 | ################################################################################ 5 | # [error-stmt-break-outside-of-loop.test.sunder:2] error: break statement outside of loop 6 | # break; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-stmt-continue-outside-of-loop.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | continue; 3 | } 4 | ################################################################################ 5 | # [error-stmt-continue-outside-of-loop.test.sunder:2] error: continue statement outside of loop 6 | # continue; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-stmt-expr-type-unsized.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | 123; 3 | } 4 | ################################################################################ 5 | # [error-stmt-expr-type-unsized.test.sunder:2] error: statement-expression produces result of unsized type `integer` 6 | # 123; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-stmt-if-non-boolean-condition.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | if (1s) { 3 | } 4 | } 5 | ################################################################################ 6 | # [error-stmt-if-non-boolean-condition.test.sunder:2] error: illegal condition with non-boolean type `ssize` 7 | # if (1s) { 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-stmt-switch-case-invalid-enum-value.test.sunder: -------------------------------------------------------------------------------- 1 | enum foo { 2 | A; 3 | B; 4 | C; 5 | } 6 | 7 | func main() void { 8 | let NOPE = (:foo)123s; 9 | switch foo::A { 10 | NOPE { } 11 | else { } 12 | } 13 | } 14 | ################################################################################ 15 | # [error-stmt-switch-case-invalid-enum-value.test.sunder:10] error: case symbol `NOPE` does not correspond to a declared value of enum type `foo` 16 | # NOPE { } 17 | # ^ 18 | -------------------------------------------------------------------------------- /tests/error-stmt-switch-case-invalid-type.test.sunder: -------------------------------------------------------------------------------- 1 | enum foo { 2 | A; 3 | B; 4 | C; 5 | } 6 | 7 | func main() void { 8 | let NOPE = 123s; 9 | switch foo::A { 10 | NOPE { } 11 | else { } 12 | } 13 | } 14 | ################################################################################ 15 | # [error-stmt-switch-case-invalid-type.test.sunder:10] error: expected case symbol with enum type `foo` (received symbol of type `ssize`) 16 | # NOPE { } 17 | # ^ 18 | -------------------------------------------------------------------------------- /tests/error-stmt-switch-else-is-not-last.test.sunder: -------------------------------------------------------------------------------- 1 | enum foo { 2 | A; 3 | B; 4 | C; 5 | } 6 | 7 | func main() void { 8 | let NOPE = (:foo)123s; 9 | switch foo::A { 10 | foo::A { } 11 | foo::B { } 12 | else { } 13 | foo::C { } 14 | } 15 | } 16 | ################################################################################ 17 | # [error-stmt-switch-else-is-not-last.test.sunder:13] error: expected `}`, found `identifier(foo)` 18 | # foo::C { } 19 | # ^ 20 | -------------------------------------------------------------------------------- /tests/error-stmt-switch-expr-not-an-enum.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | switch 123 { } 3 | } 4 | ################################################################################ 5 | # [error-stmt-switch-expr-not-an-enum.test.sunder:2] error: expected enum type (received `integer`) 6 | # switch 123 { } 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-struct-access-uninit-member.test.sunder: -------------------------------------------------------------------------------- 1 | struct s1 { 2 | var x: u32; 3 | } 4 | 5 | struct s2 { 6 | var x: u32; 7 | var y: u32; 8 | } 9 | 10 | let a = (:s2){.x = 123, .y = (:s1){.x = uninit}.x}; 11 | ################################################################################ 12 | # [error-struct-access-uninit-member.test.sunder:10] error: member `x` of type `s1` is uninitialized 13 | # let a = (:s2){.x = 123, .y = (:s1){.x = uninit}.x}; 14 | # ^ 15 | -------------------------------------------------------------------------------- /tests/error-struct-contains-incomplete-struct.test.sunder: -------------------------------------------------------------------------------- 1 | struct a { 2 | var member: b; 3 | } 4 | 5 | struct b { 6 | var member: c; 7 | } 8 | 9 | struct c { 10 | var member: a; 11 | } 12 | ################################################################################ 13 | # [error-struct-contains-incomplete-struct.test.sunder:10] error: struct `c` contains a member variable of incomplete struct type `a` 14 | # var member: a; 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-struct-contains-incomplete-union.test.sunder: -------------------------------------------------------------------------------- 1 | union a { 2 | var member: b; 3 | } 4 | 5 | struct b { 6 | var member: c; 7 | } 8 | 9 | struct c { 10 | var member: a; 11 | } 12 | ################################################################################ 13 | # [error-struct-contains-incomplete-union.test.sunder:10] error: struct `c` contains a member variable of incomplete union type `a` 14 | # var member: a; 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-struct-contains-unsized-member.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { var x: any; } 2 | ################################################################################ 3 | # [error-struct-contains-unsized-member.test.sunder:1] error: struct `foo` contains a member variable of unsized type `any` 4 | # struct foo { var x: any; } 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-struct-duplicate-member-initializer.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u16; 3 | } 4 | let a: foo = (:foo){.x = 0, .x = 1}; 5 | ################################################################################ 6 | # [error-struct-duplicate-member-initializer.test.sunder:4] error: duplicate initializer for member variable `x` 7 | # let a: foo = (:foo){.x = 0, .x = 1}; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-struct-duplicate-member-name.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: ssize; 3 | var x: ssize; 4 | } 5 | ################################################################################ 6 | # [error-struct-duplicate-member-name.test.sunder:3] error: duplicate definition of member `x` 7 | # var x: ssize; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-struct-illegal-type-conversion.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u8; 3 | } 4 | 5 | let a: foo = (:foo){.x = 123u16}; 6 | ################################################################################ 7 | # [error-struct-illegal-type-conversion.test.sunder:5] error: incompatible type `u16` (expected `u8`) 8 | # let a: foo = (:foo){.x = 123u16}; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-struct-member-parse-error.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | 1 + 1; 3 | } 4 | ################################################################################ 5 | # [error-struct-member-parse-error.test.sunder:2] error: expected member variable, member constant, member function, or type alias, found `integer(1)` 6 | # 1 + 1; 7 | # ^ 8 | -------------------------------------------------------------------------------- /tests/error-struct-missing-member-initializer.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var x: u16; 3 | var y: u16; 4 | } 5 | let a: foo = (:foo){.x = 0}; 6 | ################################################################################ 7 | # [error-struct-missing-member-initializer.test.sunder:5] error: missing initializer for member variable `y` 8 | # let a: foo = (:foo){.x = 0}; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-template-function-invalid-argument-count.test.sunder: -------------------------------------------------------------------------------- 1 | func foo[[A, B, C]]() void { 2 | } 3 | 4 | func main() void { 5 | foo[[u32, s32]](); 6 | } 7 | ################################################################################ 8 | # [error-template-function-invalid-argument-count.test.sunder:5] error: expected 3 template argument(s) for template `foo` (received 2) 9 | # foo[[u32, s32]](); 10 | # ^ 11 | -------------------------------------------------------------------------------- /tests/error-template-function-no-parameters.test.sunder: -------------------------------------------------------------------------------- 1 | func foo[[]](x: usize, y: ssize) void { 2 | } 3 | ################################################################################ 4 | # [error-template-function-no-parameters.test.sunder:1] error: template parameter list declared with zero parameters 5 | # func foo[[]](x: usize, y: ssize) void { 6 | # ^ 7 | -------------------------------------------------------------------------------- /tests/error-template-type-must-be-instantiated.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo[[T]] { 2 | var value: T; 3 | } 4 | 5 | let a: foo = (:foo[[u16]]){.value = 123}; 6 | ################################################################################ 7 | # [error-template-type-must-be-instantiated.test.sunder:5] error: template `foo` must be instantiated 8 | # let a: foo = (:foo[[u16]]){.value = 123}; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/error-type-struct-duplicate-member-name.test.sunder: -------------------------------------------------------------------------------- 1 | let a: struct { 2 | var x: ssize; 3 | var x: ssize; 4 | } = uninit; 5 | ################################################################################ 6 | # [error-type-struct-duplicate-member-name.test.sunder:3] error: duplicate definition of member `x` 7 | # var x: ssize; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-type-union-duplicate-member-name.test.sunder: -------------------------------------------------------------------------------- 1 | let a: union { 2 | var x: ssize; 3 | var x: ssize; 4 | } = uninit; 5 | ################################################################################ 6 | # [error-type-union-duplicate-member-name.test.sunder:3] error: duplicate definition of member `x` 7 | # var x: ssize; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-unexpected-end-of-line-in-bytes-literal.test.sunder: -------------------------------------------------------------------------------- 1 | let a: []byte = "abc 2 | ################################################################################ 3 | # [error-unexpected-end-of-line-in-bytes-literal.test.sunder:1] error: end-of-line encountered in bytes literal 4 | # let a: []byte = "abc 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-unexpected-end-of-line-in-character-literal.test.sunder: -------------------------------------------------------------------------------- 1 | let a: byte = 'a 2 | ################################################################################ 3 | # [error-unexpected-end-of-line-in-character-literal.test.sunder:1] error: end-of-line encountered in character literal 4 | # let a: byte = 'a 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-unexpected-prefix-token-end-of-file.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | ################################################################################ 3 | # [error-unexpected-prefix-token-end-of-file.test.sunder:4] error: unrecognized prefix token `end-of-file` in expression 4 | -------------------------------------------------------------------------------- /tests/error-union-contains-incomplete-struct.test.sunder: -------------------------------------------------------------------------------- 1 | struct a { 2 | var member: b; 3 | } 4 | 5 | union b { 6 | var member: c; 7 | } 8 | 9 | union c { 10 | var member: a; 11 | } 12 | ################################################################################ 13 | # [error-union-contains-incomplete-struct.test.sunder:10] error: union `c` contains a member variable of incomplete struct type `a` 14 | # var member: a; 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-union-contains-incomplete-union.test.sunder: -------------------------------------------------------------------------------- 1 | union a { 2 | var member: b; 3 | } 4 | 5 | union b { 6 | var member: c; 7 | } 8 | 9 | union c { 10 | var member: a; 11 | } 12 | ################################################################################ 13 | # [error-union-contains-incomplete-union.test.sunder:10] error: union `c` contains a member variable of incomplete union type `a` 14 | # var member: a; 15 | # ^ 16 | -------------------------------------------------------------------------------- /tests/error-union-contains-unsized-member.test.sunder: -------------------------------------------------------------------------------- 1 | union foo { var x: any; } 2 | ################################################################################ 3 | # [error-union-contains-unsized-member.test.sunder:1] error: union `foo` contains a member variable of unsized type `any` 4 | # union foo { var x: any; } 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-union-duplicate-member-name.test.sunder: -------------------------------------------------------------------------------- 1 | union foo { 2 | var x: ssize; 3 | var x: ssize; 4 | } 5 | ################################################################################ 6 | # [error-union-duplicate-member-name.test.sunder:3] error: duplicate definition of member `x` 7 | # var x: ssize; 8 | # ^ 9 | -------------------------------------------------------------------------------- /tests/error-use-of-incomplete-type.test.sunder: -------------------------------------------------------------------------------- 1 | struct baz { 2 | let VAL: typeof(qux::VAL) = 123; 3 | } 4 | 5 | struct qux { 6 | let VAL: typeof(baz::VAL) = 123; 7 | } 8 | ################################################################################ 9 | # [error-use-of-incomplete-type.test.sunder:6] error: use of incomplete type `baz` 10 | # let VAL: typeof(baz::VAL) = 123; 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/error-use-of-type-as-expression.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = usize; 2 | ################################################################################ 3 | # [error-use-of-type-as-expression.test.sunder:1] error: use of type `usize` as an expression 4 | # let foo: ssize = usize; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-use-of-undeclared-identifier-expr.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: ssize = bar; 2 | ################################################################################ 3 | # [error-use-of-undeclared-identifier-expr.test.sunder:1] error: use of undeclared identifier `bar` 4 | # let foo: ssize = bar; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/error-use-of-undeclared-identifier-type.test.sunder: -------------------------------------------------------------------------------- 1 | let foo: bar = 1s; 2 | ################################################################################ 3 | # [error-use-of-undeclared-identifier-type.test.sunder:1] error: use of undeclared identifier `bar` 4 | # let foo: bar = 1s; 5 | # ^ 6 | -------------------------------------------------------------------------------- /tests/example-byte.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | let gc0: byte = 0xABy; 4 | let gc1: byte = gc0; 5 | 6 | var gv0: byte = 0xBCy; 7 | 8 | func main() void { 9 | sys::dump[[byte]](gc0); 10 | sys::dump[[byte]](gc1); 11 | 12 | sys::dump[[byte]](gv0); 13 | var x: byte = gv0; 14 | sys::dump[[byte]](x); 15 | 16 | let lc0: byte = 0xCDy; 17 | let lc1: byte = lc0; 18 | 19 | var lv0: byte = 0xDEy; 20 | var lv1: byte = lv0; 21 | 22 | sys::dump[[byte]](lc0); 23 | sys::dump[[byte]](lc1); 24 | 25 | sys::dump[[byte]](lv0); 26 | sys::dump[[byte]](lv1); 27 | } 28 | ################################################################################ 29 | # AB 30 | # AB 31 | # BC 32 | # BC 33 | # CD 34 | # CD 35 | # DE 36 | # DE 37 | -------------------------------------------------------------------------------- /tests/example-hello.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | std::print_line(std::out(), "Hello, world!"); 5 | } 6 | ################################################################################ 7 | # Hello, world! 8 | -------------------------------------------------------------------------------- /tests/expr-array.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | let a: [5u]u16 = (:[5u]u16)[0xAAAAu16, 0xBBBBu16, 0xCCCCu16, 0xDDDDu16, 0xEEEEu16]; 4 | 5 | func main() void { 6 | var b: [5u]u16 = (:[5u]u16)[0xAAAAu16, 0xBBBBu16, 0xCCCCu16, 0xDDDDu16, 0xEEEEu16]; 7 | 8 | sys::dump[[[5]u16]](a); 9 | sys::dump[[[5]u16]](b); 10 | } 11 | ################################################################################ 12 | # AA AA BB BB CC CC DD DD EE EE 13 | # AA AA BB BB CC CC DD DD EE EE 14 | -------------------------------------------------------------------------------- /tests/expr-call-member-function-builtin-type.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var a = 0xAAAAu16; 5 | a.dumpme(); 6 | } 7 | 8 | extend u16 func dumpme(self: *u16) void { 9 | sys::dump[[u16]](*self); 10 | } 11 | ################################################################################ 12 | # AA AA 13 | -------------------------------------------------------------------------------- /tests/expr-call-member-function-lvalue.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | struct foo { 4 | var x: u16; 5 | 6 | func fn(self: *foo) void { 7 | sys::dump[[u16]](self.*.x); 8 | } 9 | } 10 | 11 | func main() void { 12 | var lvalue = (:foo){.x = 0xAABB}; 13 | lvalue.fn(); 14 | } 15 | ################################################################################ 16 | # BB AA 17 | -------------------------------------------------------------------------------- /tests/expr-call-member-function-rvalue.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | struct foo { 4 | var x: u16; 5 | 6 | func fn(self: *foo) void { 7 | sys::dump[[u16]](self.*.x); 8 | } 9 | } 10 | 11 | func main() void { 12 | (:foo){.x = 0xAABB}.fn(); 13 | } 14 | ################################################################################ 15 | # BB AA 16 | -------------------------------------------------------------------------------- /tests/expr-call-trailing-comma.test.sunder: -------------------------------------------------------------------------------- 1 | func f(a_: usize) void { 2 | } 3 | 4 | func g(a_: usize, b_: usize) void { 5 | } 6 | 7 | func h(a_: usize, b_: usize, c_: usize) void { 8 | } 9 | 10 | func main() void { 11 | f(123,); 12 | g(123, 456,); 13 | g( 14 | 123, 15 | 456, 16 | ); 17 | h(123, 456, 789,); 18 | h( 19 | 123, 20 | 456, 21 | 789, 22 | ); 23 | } 24 | -------------------------------------------------------------------------------- /tests/expr-cast-from-bool-to-bool.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | sys::dump[[bool]]((:bool)true); 5 | sys::dump[[bool]]((:bool)false); 6 | 7 | var x = true; 8 | sys::dump[[bool]]((:bool)x); 9 | sys::dump[[bool]]((:bool)(:bool)x); 10 | 11 | let y = true; 12 | sys::dump[[bool]]((:bool)y); 13 | sys::dump[[bool]]((:bool)(:bool)y); 14 | } 15 | ################################################################################ 16 | # 01 17 | # 00 18 | # 01 19 | # 01 20 | # 01 21 | # 01 22 | -------------------------------------------------------------------------------- /tests/expr-cast-from-byte-to-byte.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | sys::dump[[byte]]((:byte)1y); 5 | 6 | var x = 1y; 7 | sys::dump[[byte]]((:byte)x); 8 | sys::dump[[byte]]((:byte)(:byte)x); 9 | 10 | let y = true; 11 | sys::dump[[byte]]((:byte)y); 12 | sys::dump[[byte]]((:byte)(:byte)y); 13 | } 14 | ################################################################################ 15 | # 01 16 | # 01 17 | # 01 18 | # 01 19 | # 01 20 | -------------------------------------------------------------------------------- /tests/expr-cast-from-function-to-pointer.test.sunder: -------------------------------------------------------------------------------- 1 | func foo(bar_: []byte, baz_: *u32, qux_: ssize) s32 { 2 | return 123; 3 | } 4 | 5 | var a = (:*any)foo; 6 | let b = (:*any)foo; 7 | 8 | func main() void { 9 | var x_ = (:*any)foo; 10 | let y_ = (:*any)foo; 11 | } 12 | -------------------------------------------------------------------------------- /tests/expr-cast-from-pointer-to-function.test.sunder: -------------------------------------------------------------------------------- 1 | let ptr = (:*any)123u; 2 | 3 | func main() void { 4 | var x_ = (:func([]byte, *u32, ssize) s32)ptr; 5 | } 6 | -------------------------------------------------------------------------------- /tests/expr-cast-from-type-unsized-integer.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | sys::dump[[bool]]((:bool)123); 5 | sys::dump[[byte]]((:byte)123); 6 | sys::dump[[u8]]((:u8)123); 7 | sys::dump[[usize]]((:usize)123); 8 | 9 | sys::dump[[bool]]((:bool)(123 + 1)); 10 | sys::dump[[byte]]((:byte)(123 + 1)); 11 | sys::dump[[u8]]((:u8)(123 + 1)); 12 | sys::dump[[usize]]((:usize)(123 + 1)); 13 | } 14 | ################################################################################ 15 | # 01 16 | # 7B 17 | # 7B 18 | # 7B 00 00 00 00 00 00 00 19 | # 01 20 | # 7C 21 | # 7C 22 | # 7C 00 00 00 00 00 00 00 23 | -------------------------------------------------------------------------------- /tests/expr-defined.test.sunder: -------------------------------------------------------------------------------- 1 | struct s { 2 | var variable: usize; 3 | let constant: usize = 123; 4 | func function() usize { return 123; } 5 | } 6 | 7 | func main() void { 8 | assert defined(main); 9 | assert defined(::main); 10 | assert not defined(nope); 11 | assert not defined(foo::bar::baz); 12 | 13 | assert not defined(s::variable); 14 | assert defined(s::constant); 15 | assert defined(s::function); 16 | assert not defined(s::nope); 17 | } 18 | -------------------------------------------------------------------------------- /tests/expr-embed.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let x = embed("data.txt"); 4 | 5 | func main() void { 6 | let y = embed("data.txt"); 7 | 8 | std::print_line(std::out(), std::ascii::view_trimmed(x)); 9 | std::print_line(std::out(), std::ascii::view_trimmed(y)); 10 | 11 | # Embed expressions are treaded like bytes-literals by the compiler, so you 12 | # can get a compile-time string count and compile-time address of the textr 13 | let _ = countof(embed("data.txt")); 14 | let _ = &embed("data.txt"); 15 | } 16 | ################################################################################ 17 | # TEST DATA FILE LINE 1 18 | # TEST DATA FILE LINE 2 19 | # TEST DATA FILE LINE 1 20 | # TEST DATA FILE LINE 2 21 | -------------------------------------------------------------------------------- /tests/expr-f32-nan-constant-expression.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let x = 0.0f32 / 0.0f32; 4 | 5 | func main() void { 6 | std::print_format_line( 7 | std::out(), 8 | "{}", 9 | (:[]std::formatter)[std::formatter::init[[f32]](&x)]); 10 | std::print_format_line( 11 | std::out(), 12 | "{}", 13 | (:[]std::formatter)[std::formatter::init[[f32]](&f32::NAN)]); 14 | } 15 | ################################################################################ 16 | # NaN 17 | # NaN 18 | -------------------------------------------------------------------------------- /tests/expr-f32-negative-inf-constant-expression.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let x = -1.0f32 / 0.0f32; 4 | 5 | func main() void { 6 | std::print_format_line( 7 | std::out(), 8 | "{}", 9 | (:[]std::formatter)[std::formatter::init[[f32]](&x)]); 10 | var neg_inf = -f32::INFINITY; 11 | std::print_format_line( 12 | std::out(), 13 | "{}", 14 | (:[]std::formatter)[std::formatter::init[[f32]](&neg_inf)]); 15 | } 16 | ################################################################################ 17 | # -infinity 18 | # -infinity 19 | -------------------------------------------------------------------------------- /tests/expr-f32-positive-inf-constant-expression.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let x = +1.0f32 / 0.0f32; 4 | 5 | func main() void { 6 | std::print_format_line( 7 | std::out(), 8 | "{}", 9 | (:[]std::formatter)[std::formatter::init[[f32]](&x)]); 10 | std::print_format_line( 11 | std::out(), 12 | "{}", 13 | (:[]std::formatter)[std::formatter::init[[f32]](&f32::INFINITY)]); 14 | } 15 | ################################################################################ 16 | # infinity 17 | # infinity 18 | -------------------------------------------------------------------------------- /tests/expr-f64-nan-constant-expression.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let x = 0.0f64 / 0.0f64; 4 | 5 | func main() void { 6 | std::print_format_line( 7 | std::out(), 8 | "{}", 9 | (:[]std::formatter)[std::formatter::init[[f64]](&x)]); 10 | std::print_format_line( 11 | std::out(), 12 | "{}", 13 | (:[]std::formatter)[std::formatter::init[[f64]](&f64::NAN)]); 14 | } 15 | ################################################################################ 16 | # NaN 17 | # NaN 18 | -------------------------------------------------------------------------------- /tests/expr-f64-negative-inf-constant-expression.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let x = -1.0f64 / 0.0f64; 4 | 5 | func main() void { 6 | std::print_format_line( 7 | std::out(), 8 | "{}", 9 | (:[]std::formatter)[std::formatter::init[[f64]](&x)]); 10 | var neg_inf = -f64::INFINITY; 11 | std::print_format_line( 12 | std::out(), 13 | "{}", 14 | (:[]std::formatter)[std::formatter::init[[f64]](&neg_inf)]); 15 | } 16 | ################################################################################ 17 | # -infinity 18 | # -infinity 19 | -------------------------------------------------------------------------------- /tests/expr-f64-positive-inf-constant-expression.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let x = +1.0f64 / 0.0f64; 4 | 5 | func main() void { 6 | std::print_format_line( 7 | std::out(), 8 | "{}", 9 | (:[]std::formatter)[std::formatter::init[[f64]](&x)]); 10 | std::print_format_line( 11 | std::out(), 12 | "{}", 13 | (:[]std::formatter)[std::formatter::init[[f64]](&f64::INFINITY)]); 14 | } 15 | ################################################################################ 16 | # infinity 17 | # infinity 18 | -------------------------------------------------------------------------------- /tests/expr-fileof.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let a = fileof(); 4 | 5 | func main() void { 6 | let b = fileof(); 7 | let c = &fileof(); 8 | 9 | std::print_line(std::out(), a); 10 | std::print_line(std::out(), b); 11 | std::print_line(std::out(), *c); 12 | } 13 | ################################################################################ 14 | # expr-fileof.test.sunder 15 | # expr-fileof.test.sunder 16 | # expr-fileof.test.sunder 17 | -------------------------------------------------------------------------------- /tests/expr-integer.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | sys::dump[[s32]](+123s32); 5 | sys::dump[[s32]](-123s32); 6 | 7 | sys::dump[[u32]](0b11011110101011011011111011101111u32); 8 | sys::dump[[u32]](0xDEADBEEFu32); 9 | sys::dump[[u32]](0o77777777u32); 10 | } 11 | ################################################################################ 12 | # 7B 00 00 00 13 | # 85 FF FF FF 14 | # EF BE AD DE 15 | # EF BE AD DE 16 | # FF FF FF 00 17 | -------------------------------------------------------------------------------- /tests/expr-lineof.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let a = lineof(); 4 | 5 | func main() void { 6 | let b = lineof(); 7 | 8 | std::print_format_line(std::out(), "{}", (:[]std::formatter)[std::formatter::init[[usize]](&a)]); 9 | std::print_format_line(std::out(), "{}", (:[]std::formatter)[std::formatter::init[[usize]](&b)]); 10 | } 11 | ################################################################################ 12 | # 3 13 | # 6 14 | -------------------------------------------------------------------------------- /tests/expr-unary-addressof.test.sunder: -------------------------------------------------------------------------------- 1 | var w = 123u; 2 | var x = &w; # Can take address of a global variable. 3 | 4 | let y = 123s; 5 | let z = &y; # Can take address of a global constant. 6 | 7 | func main() void { 8 | var a = 123u; 9 | var b = &a; # Can take address of a local variable. 10 | 11 | let c = 123s; 12 | let d = &c; # Can take address of a local constant. 13 | 14 | var p = &(123s + 456s); # Can take address of a local rvalue. 15 | 16 | assert w == x.*; 17 | assert y == z.*; 18 | assert a == b.*; 19 | assert c == d.*; 20 | assert p.* == 579s; 21 | } 22 | -------------------------------------------------------------------------------- /tests/expr-unary-neg.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func test[[T]](value: T) void { 4 | value = -value; 5 | std::print_format_line( 6 | std::out(), 7 | "{}", 8 | (:[]std::formatter)[std::formatter::init[[T]](&value)]); 9 | } 10 | 11 | func main() void { 12 | test[[s8]](+100); 13 | test[[s8]](-100); 14 | test[[s8]](+127); 15 | test[[s8]](-128); 16 | } 17 | ################################################################################ 18 | # -100 19 | # 100 20 | # -127 21 | # fatal: operation produces out-of-range result 22 | -------------------------------------------------------------------------------- /tests/expr-unary-not.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | let not_t: bool = not true; 5 | let not_f: bool = not false; 6 | sys::dump[[bool]](not_t); 7 | sys::dump[[bool]](not_f); 8 | sys::dump[[bool]](not true); 9 | sys::dump[[bool]](not false); 10 | } 11 | ################################################################################ 12 | # 00 13 | # 01 14 | # 00 15 | # 01 16 | -------------------------------------------------------------------------------- /tests/expr-unary-startof.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var a = (:[3]ssize)[123, 456, 789]; 5 | var s = (:[]ssize){&a[0], 3}; 6 | assert startof(s) == &a[0]; 7 | 8 | let a = (:[3]ssize)[123, 456, 789]; 9 | let s = (:[]ssize){&a[0], 3}; 10 | assert startof(s) == &a[0]; 11 | 12 | var s = (:[]ssize)[123, 456, 789]; 13 | assert startof(s) == &s[0]; 14 | 15 | let s = (:[]ssize)[123, 456, 789]; 16 | assert startof(s) == &s[0]; 17 | 18 | var s = (:[]ssize){std::ptr[[ssize]]::NULL, 0}; 19 | assert startof(s) == std::ptr[[ssize]]::NULL; 20 | 21 | } 22 | -------------------------------------------------------------------------------- /tests/github-issue-100.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct a { 4 | var member: b; 5 | } 6 | 7 | struct b { 8 | var member: c; 9 | } 10 | 11 | struct c { 12 | var member: a; 13 | } 14 | 15 | func main() void { 16 | sizeof(a); 17 | sizeof(b); 18 | sizeof(c); 19 | } 20 | ################################################################################ 21 | # [github-issue-100.test.sunder:12] error: struct `c` contains a member variable of incomplete struct type `a` 22 | # var member: a; 23 | # ^ 24 | -------------------------------------------------------------------------------- /tests/github-issue-101-explicit-type.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct foo { 4 | var x: u32; 5 | var y: u32; 6 | let C: foo = (:foo){}; 7 | var z: u32; 8 | } 9 | 10 | func main() void { 11 | sizeof(foo); 12 | } 13 | ################################################################################ 14 | # [github-issue-101-explicit-type.test.sunder:6] error: struct type `foo` is incomplete 15 | # let C: foo = (:foo){}; 16 | # ^ 17 | -------------------------------------------------------------------------------- /tests/github-issue-101-implicit-type.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct foo { 4 | var x: u32; 5 | var y: u32; 6 | let C = (:foo){}; 7 | var z: u32; 8 | } 9 | 10 | func main() void { 11 | sizeof(foo); 12 | } 13 | ################################################################################ 14 | # [github-issue-101-implicit-type.test.sunder:6] error: struct type `foo` is incomplete 15 | # let C = (:foo){}; 16 | # ^ 17 | -------------------------------------------------------------------------------- /tests/github-issue-105.test.sunder: -------------------------------------------------------------------------------- 1 | let a = (:foo){}; 2 | 3 | struct foo { 4 | var x: []byte; 5 | } 6 | ################################################################################ 7 | # [github-issue-105.test.sunder:1] error: missing initializer for member variable `x` 8 | # let a = (:foo){}; 9 | # ^ 10 | -------------------------------------------------------------------------------- /tests/github-issue-114.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var a: usize; 3 | var b: ssize; 4 | 5 | let c: foo = (:foo) { 6 | }; 7 | } 8 | ################################################################################ 9 | # [github-issue-114.test.sunder:5] error: missing initializer for member variable `a` 10 | # let c: foo = (:foo) { 11 | # ^ 12 | -------------------------------------------------------------------------------- /tests/github-issue-118.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | # Previously this did not compile. 5 | var map_ = std::hash_map[[s32, void]]::init_with_allocator(std::null_allocator::ALLOCATOR); 6 | } 7 | -------------------------------------------------------------------------------- /tests/github-issue-119.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct foo { 4 | var map: std::hash_map[[ssize, bar]]; 5 | } 6 | 7 | struct bar { 8 | var baz: []byte; 9 | } 10 | 11 | func main() void { 12 | } 13 | -------------------------------------------------------------------------------- /tests/github-issue-120.test.sunder: -------------------------------------------------------------------------------- 1 | import "github-issue-120"; 2 | 3 | # Just make sure that the imported module compiles. 4 | func main() void { } 5 | -------------------------------------------------------------------------------- /tests/github-issue-122.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var a: u32; 3 | var b: s32; 4 | } 5 | 6 | func bar(foo: *foo) foo { 7 | var x: ::foo = *foo; 8 | return x; 9 | } 10 | 11 | func baz(ssize: *ssize) ssize { 12 | return *ssize; 13 | } 14 | 15 | func main() void { 16 | var x = (:foo){.a = 123, .b = 456}; 17 | bar(&x); 18 | 19 | var x = 123s; 20 | baz(&x); 21 | } 22 | -------------------------------------------------------------------------------- /tests/github-issue-123.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var x = s64::MIN / -1; 5 | std::print_format(std::out(), "{}", (:[]std::formatter)[std::formatter::init[[typeof(x)]](&x)]); 6 | } 7 | ################################################################################ 8 | # fatal: operation produces out-of-range result 9 | -------------------------------------------------------------------------------- /tests/github-issue-125.test.sunder: -------------------------------------------------------------------------------- 1 | import "github-issue-125/import.sunder"; 2 | 3 | func main() void { 4 | } 5 | -------------------------------------------------------------------------------- /tests/github-issue-125/import.sunder: -------------------------------------------------------------------------------- 1 | namespace lib; 2 | 3 | enum e { 4 | A; 5 | B; 6 | C; 7 | } 8 | 9 | var x: e = uninit; 10 | var y: lib::e = uninit; 11 | var z: ::lib::e = uninit; 12 | 13 | 14 | struct s { 15 | var x: e; 16 | var y: lib::e; 17 | var z: ::lib::e; 18 | } 19 | -------------------------------------------------------------------------------- /tests/github-issue-126.test.sunder: -------------------------------------------------------------------------------- 1 | struct x { } 2 | 3 | func main() void { 4 | var x = 123u; 5 | var x = (: ::x){}; # no warning emitted 6 | var x = (:::x){}; 7 | } 8 | ################################################################################ 9 | # [github-issue-126.test.sunder:6] warning: `:::` is parsed as `:: :` 10 | # var x = (:::x){}; 11 | # ^ 12 | # [github-issue-126.test.sunder:6] info: write as `: ::` to disambiguate 13 | # var x = (:::x){}; 14 | # ^ 15 | # [github-issue-126.test.sunder:6] error: expected `identifier`, found `:` 16 | # var x = (:::x){}; 17 | # ^ 18 | -------------------------------------------------------------------------------- /tests/github-issue-134.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func test[[T]](str: []byte) void { 4 | std::print_format_line(std::err(), "parsing {}", (:[]std::formatter)[std::formatter::init[[typeof(str)]](&str)]); 5 | var x = T::init_from_str(str, 0); 6 | if x.is_value() { 7 | std::print_line(std::err(), "...parsed"); 8 | } 9 | else { 10 | std::print_line(std::err(), x.error().*.data); 11 | } 12 | } 13 | 14 | func main() void { 15 | test[[u8]]("0x00"); 16 | test[[u8]]("-0x00"); 17 | test[[u8]]("-0x01"); 18 | } 19 | ################################################################################ 20 | # parsing 0x00 21 | # ...parsed 22 | # parsing -0x00 23 | # ...parsed 24 | # parsing -0x01 25 | # result out-of-range 26 | -------------------------------------------------------------------------------- /tests/github-issue-139.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo { 2 | var kind: enum { 3 | X; 4 | }; 5 | } 6 | 7 | union bar { 8 | var kind: enum { 9 | X; 10 | }; 11 | } 12 | 13 | func main() void { 14 | } 15 | -------------------------------------------------------------------------------- /tests/github-issue-77/import.sunder: -------------------------------------------------------------------------------- 1 | namespace foo; 2 | 3 | let bar = 123s; 4 | -------------------------------------------------------------------------------- /tests/github-issue-84.test.sunder: -------------------------------------------------------------------------------- 1 | struct foo[[T]] { 2 | let INDEX: T = 1; 3 | } 4 | 5 | func main() void { 6 | var x = (:[][]ssize)[(:[]ssize)[0x123, 0x456], (:[]ssize)[0x789, 0xABC, 0xDEF]]; 7 | x[0][foo[[usize]]::INDEX]; 8 | } 9 | -------------------------------------------------------------------------------- /tests/github-issue-93.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | struct foo { 4 | var value: u32; 5 | 6 | func as[[T]](self: *foo) T { 7 | return (:T)self.*.value; 8 | } 9 | } 10 | 11 | func main() void { 12 | var x = (:foo){.value = 0xDEADBEEF}; 13 | sys::dump[[u32]](x.value); 14 | sys::dump[[usize]](foo::as[[usize]](&x)); 15 | sys::dump[[usize]](x.as[[usize]]()); 16 | } 17 | ################################################################################ 18 | # EF BE AD DE 19 | # EF BE AD DE 00 00 00 00 20 | # EF BE AD DE 00 00 00 00 21 | -------------------------------------------------------------------------------- /tests/implcit-cast-from-typed-pointer-to-any-pointer.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | let a: u16 = 0xBEEF; 4 | let b: *u16 = &a; 5 | 6 | var c: *u16 = &a; 7 | let d: *any = &a; 8 | 9 | func f(x: *u16, b: u32) *u16 { 10 | *x = (:u16)b; 11 | return x; 12 | } 13 | 14 | func main() void { 15 | var e: *any = &a; 16 | var g: func(*any, u32) *any = f; 17 | 18 | var my_x: u16 = 0xF00D; 19 | g(&my_x, 0xDEADBEEF); 20 | 21 | sys::dump[[bool]]((:usize)b == (:usize)c); 22 | sys::dump[[bool]]((:usize)b == (:usize)d); 23 | sys::dump[[bool]]((:usize)b == (:usize)e); 24 | sys::dump[[u16]](my_x); 25 | } 26 | ################################################################################ 27 | # 01 28 | # 01 29 | # 01 30 | # EF BE 31 | -------------------------------------------------------------------------------- /tests/import-directory.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | import "import"; 4 | import "import/c"; 5 | 6 | func main() void { 7 | sys::dump[[u16]](a); 8 | sys::dump[[u16]](b()); 9 | c = c + 1u16; 10 | sys::dump[[u16]](c); 11 | 12 | std::print_line(std::out(), "imported from the standard library"); 13 | } 14 | ################################################################################ 15 | # AA AA 16 | # BB BB 17 | # CC CC 18 | # imported from the standard library 19 | -------------------------------------------------------------------------------- /tests/import-platform-specific.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | # Test that importing a directory containing platform specific files will only 4 | # load modules that contain a tag matching the arch and/or host. 5 | import "import-platform-specific"; 6 | 7 | func main() void { 8 | assert defined(PLATFORM_SPECIFIC_ARCH); # module.*.sunder 9 | assert defined(PLATFORM_SPECIFIC_HOST); # module.*.sunder 10 | assert defined(NO_PLATFORM_SPECIFIC_OVERRIDE); # module-with-no-platform-specific-override.sunder 11 | } 12 | -------------------------------------------------------------------------------- /tests/import-platform-specific/module-with-no-platform-specific-override.sunder: -------------------------------------------------------------------------------- 1 | # This module does not have a platform specific override, such as: 2 | # 3 | # module-with-no-platform-specific-override.amd64.sunder 4 | # 5 | # or 6 | # 7 | # module-with-no-platform-specific-override.linux.sunder 8 | # 9 | # so it will not be skipped by a directory import. 10 | 11 | let NO_PLATFORM_SPECIFIC_OVERRIDE = true; 12 | -------------------------------------------------------------------------------- /tests/import-platform-specific/module.amd64.sunder: -------------------------------------------------------------------------------- 1 | let PLATFORM_SPECIFIC_ARCH = true; 2 | -------------------------------------------------------------------------------- /tests/import-platform-specific/module.arm64.sunder: -------------------------------------------------------------------------------- 1 | let PLATFORM_SPECIFIC_ARCH = true; 2 | -------------------------------------------------------------------------------- /tests/import-platform-specific/module.linux.sunder: -------------------------------------------------------------------------------- 1 | let PLATFORM_SPECIFIC_HOST = true; 2 | -------------------------------------------------------------------------------- /tests/import-platform-specific/module.macos.sunder: -------------------------------------------------------------------------------- 1 | let PLATFORM_SPECIFIC_HOST = true; 2 | -------------------------------------------------------------------------------- /tests/import-platform-specific/module.pdp11.sunder: -------------------------------------------------------------------------------- 1 | # This module, written in K&R Sunder, will not compile with the standard Sunder 2 | # compiler! Thankfully, the module is tagged with "pdp11", so sunder-compile 3 | # will skip this module when the "import-platform-specific" directory is 4 | # imported, as "pdp11" does not match the arch or host tags for any of the 5 | # platforms supported by Sunder. 6 | 7 | main() { 8 | printf("hello, world\n"); 9 | } 10 | -------------------------------------------------------------------------------- /tests/import-platform-specific/module.sunder: -------------------------------------------------------------------------------- 1 | let PLATFORM_SPECIFIC_ARCH = false; 2 | let PLATFORM_SPECIFIC_HOST = false; 3 | -------------------------------------------------------------------------------- /tests/import.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | import "import/a.sunder"; 5 | import "import/b.sunder"; 6 | import "import/c/c.sunder"; 7 | 8 | func main() void { 9 | sys::dump[[u16]](a); 10 | sys::dump[[u16]](b()); 11 | c = c + 1u16; 12 | sys::dump[[u16]](c); 13 | 14 | std::print_line(std::out(), "imported from the standard library"); 15 | } 16 | ################################################################################ 17 | # AA AA 18 | # BB BB 19 | # CC CC 20 | # imported from the standard library 21 | -------------------------------------------------------------------------------- /tests/import/a.sunder: -------------------------------------------------------------------------------- 1 | let a: u16 = 0xAAAAu16; 2 | -------------------------------------------------------------------------------- /tests/import/b.sunder: -------------------------------------------------------------------------------- 1 | import "a.sunder"; 2 | 3 | func b() u16 { 4 | return a + 0x1111u16; 5 | } 6 | -------------------------------------------------------------------------------- /tests/import/c/c.sunder: -------------------------------------------------------------------------------- 1 | var c: u16 = 0xCCCBu16; 2 | -------------------------------------------------------------------------------- /tests/namespace.test.sunder: -------------------------------------------------------------------------------- 1 | import "namespace/import1.sunder"; 2 | import "namespace/import2.sunder"; 3 | import "namespace/import3.sunder"; 4 | 5 | func main() void { 6 | foo::bar::a; 7 | foo::bar::b; 8 | foo::bar::c(); 9 | foo::bar::d; 10 | foo::baz; 11 | } 12 | -------------------------------------------------------------------------------- /tests/namespace/import1.sunder: -------------------------------------------------------------------------------- 1 | namespace foo::bar; 2 | 3 | # Out-of-order dependecy on b. 4 | # References b using a fully qualified identifier. 5 | var b2: byte = ::foo::bar::b; 6 | 7 | # Out-of-order dependecy on b. 8 | # References b using an unqualified identifier. 9 | var b3: byte = b; 10 | 11 | # Make sure that the module symbol table was properly set to foo::bar. No name 12 | # collisions should occur for either the foo or bar identifiers (foo::bar::foo 13 | # and foo::bar::bar respectively). 14 | let foo: u16 = 0xBEEFu16; 15 | let bar: u16 = 0xBEEFu16; 16 | 17 | var a: byte = 0xAAy; 18 | 19 | let b: byte = 0xBBy; 20 | 21 | func c() byte { 22 | var result: u8 = (:u8)b; 23 | result = result + 0x11u8; 24 | return (:byte)result; 25 | } 26 | -------------------------------------------------------------------------------- /tests/namespace/import2.sunder: -------------------------------------------------------------------------------- 1 | namespace foo::bar; 2 | 3 | let d: byte = 0xDDy; 4 | -------------------------------------------------------------------------------- /tests/namespace/import3.sunder: -------------------------------------------------------------------------------- 1 | namespace foo; 2 | 3 | let baz: u16 = 0xBEEFu16; 4 | -------------------------------------------------------------------------------- /tests/operator-precedence.test.sunder: -------------------------------------------------------------------------------- 1 | # This file is mostly for verifying fixes for whack-a-mole precedence bugs as 2 | # they come up rather than a full operator precedence test suite. 3 | import "sys"; 4 | 5 | func main() void { 6 | # $ python3 -c "print(hex(0xAA + 0xBB * 0xCC - 0xDD))" 7 | # 0x94d1 8 | sys::dump[[s64]](0xAAs64 + 0xBBs64 * 0xCCs64 - 0xDDs64); 9 | 10 | var str: []byte = "foobar"; 11 | var pb: *byte = (:*byte)((:usize)&str[0u] + 3u); 12 | sys::dump[[byte]](*pb); 13 | } 14 | ################################################################################ 15 | # D1 94 00 00 00 00 00 00 16 | # 62 17 | -------------------------------------------------------------------------------- /tests/order-independent-top-level-declarations.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | let baz: ssize = bar + 1s; 4 | let foo: ssize = 1s; 5 | let bar: ssize = foo + 1s; 6 | 7 | func fn_a() void { 8 | fn_b(); 9 | } 10 | func fn_b() void { 11 | fn_a(); 12 | } 13 | 14 | func main() void { 15 | sys::dump[[ssize]](foo); 16 | sys::dump[[ssize]](bar); 17 | sys::dump[[ssize]](baz); 18 | } 19 | ################################################################################ 20 | # 01 00 00 00 00 00 00 00 21 | # 02 00 00 00 00 00 00 00 22 | # 03 00 00 00 00 00 00 00 23 | -------------------------------------------------------------------------------- /tests/reserved-c-identifiers.test.sunder: -------------------------------------------------------------------------------- 1 | # Reserved C identifiers may be used in Sunder, provided that they are not 2 | # themselves reserved in the Sunder language. 3 | 4 | var _Pragma: bool = uninit; 5 | var pragma: bool = uninit; 6 | var unsigned: bool = uninit; 7 | var signed: bool = uninit; 8 | var while: bool = uninit; 9 | var _Atomic: bool = uninit; 10 | var _Generic: bool = uninit; 11 | var const: bool = uninit; 12 | var volatile: bool = uninit; 13 | var restrict: bool = uninit; 14 | 15 | func main() void { } 16 | -------------------------------------------------------------------------------- /tests/std-argument_parser-error-missing-required-option-argument.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "util"; 3 | 4 | func main() void { 5 | var parser = std::argument_parser::init_from_argv( 6 | (:[][]byte)[ 7 | "a", 8 | "b", 9 | "c:" 10 | ], 11 | util::argv::new((:[][]byte)[ 12 | "arg0", 13 | "-a", 14 | "-b", 15 | "-c" 16 | ]) 17 | ); 18 | 19 | for parser.advance() { } 20 | } 21 | ################################################################################ 22 | # error: missing required argument for option `c` 23 | -------------------------------------------------------------------------------- /tests/std-argument_parser-error-missing-required-option.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "util"; 3 | 4 | func main() void { 5 | var parser = std::argument_parser::init_from_argv( 6 | (:[][]byte)[ 7 | "a", 8 | "b", 9 | "c:" 10 | ], 11 | util::argv::new((:[][]byte)[ 12 | "arg0", 13 | "-a", 14 | "-b", 15 | "-c" 16 | ]) 17 | ); 18 | 19 | for parser.advance() { } 20 | } 21 | ################################################################################ 22 | # error: missing required argument for option `c` 23 | -------------------------------------------------------------------------------- /tests/std-argument_parser-error-option-does-not-accept-argument.test.sunder: -------------------------------------------------------------------------------- 1 | 2 | import "std"; 3 | import "util"; 4 | 5 | func main() void { 6 | var parser = std::argument_parser::init_from_argv( 7 | (:[][]byte)[ 8 | "a:", 9 | "b" 10 | ], 11 | util::argv::new((:[][]byte)[ 12 | "arg0", 13 | "-a=a-arg", 14 | "-b=b-arg", 15 | ]) 16 | ); 17 | 18 | for parser.advance() { } 19 | } 20 | ################################################################################ 21 | # error: option `b` does not accept an argument 22 | -------------------------------------------------------------------------------- /tests/std-argument_parser-error-unrecognized-option.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "util"; 3 | 4 | func main() void { 5 | var parser = std::argument_parser::init_from_argv( 6 | (:[][]byte)[ 7 | "a", 8 | "b" 9 | ], 10 | util::argv::new((:[][]byte)[ 11 | "arg0", 12 | "-a", 13 | "-b", 14 | "-c" 15 | ]) 16 | ); 17 | 18 | for parser.advance() { } 19 | } 20 | ################################################################################ 21 | # error: unrecognized option `c` 22 | -------------------------------------------------------------------------------- /tests/std-ascii-is_letter.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | assert std::ascii::is_letter('a'); 5 | assert std::ascii::is_letter('b'); 6 | assert std::ascii::is_letter('c'); 7 | assert std::ascii::is_letter('z'); 8 | 9 | assert std::ascii::is_letter('A'); 10 | assert std::ascii::is_letter('B'); 11 | assert std::ascii::is_letter('C'); 12 | assert std::ascii::is_letter('Z'); 13 | 14 | assert not std::ascii::is_letter('1'); 15 | assert not std::ascii::is_letter('~'); 16 | assert not std::ascii::is_letter('\n'); 17 | assert not std::ascii::is_letter('\t'); 18 | assert not std::ascii::is_letter(' '); 19 | assert not std::ascii::is_letter('@'); 20 | assert not std::ascii::is_letter('['); 21 | } 22 | -------------------------------------------------------------------------------- /tests/std-ascii-is_whitespace.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | assert std::ascii::is_whitespace(' '); 5 | assert std::ascii::is_whitespace('\t'); 6 | assert std::ascii::is_whitespace('\n'); 7 | assert std::ascii::is_whitespace(0x0B); 8 | assert std::ascii::is_whitespace(0x0C); 9 | assert std::ascii::is_whitespace(0x0D); 10 | 11 | assert not std::ascii::is_whitespace('A'); 12 | assert not std::ascii::is_whitespace(0x7F); 13 | assert not std::ascii::is_whitespace(0xFF); 14 | } 15 | -------------------------------------------------------------------------------- /tests/std-bool-eq.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | let T = true; 5 | let F = false; 6 | 7 | assert std::eq[[bool]](&T, &T); 8 | assert std::eq[[bool]](&F, &F); 9 | assert not std::eq[[bool]](&T, &F); 10 | } 11 | -------------------------------------------------------------------------------- /tests/std-bool-format.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var t = true; 5 | var f = false; 6 | std::print_format_line( 7 | std::out(), 8 | "{} {}", 9 | (:[]std::formatter)[ 10 | std::formatter::init[[bool]](&t), 11 | std::formatter::init[[bool]](&f)]); 12 | } 13 | ################################################################################ 14 | # true false 15 | -------------------------------------------------------------------------------- /tests/std-byte-format.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func test(b: byte, format: []byte) void { 4 | std::print_format_line( 5 | std::out(), 6 | format, 7 | (:[]std::formatter)[std::formatter::init[[byte]](&b)]); 8 | } 9 | 10 | func main() void { 11 | test(0xAB, "{}"); 12 | test(0xAB, "{#}"); 13 | test(0xAB, "{b}"); 14 | test(0xAB, "{#b}"); 15 | test(0xAB, "{o}"); 16 | test(0xAB, "{#o}"); 17 | test(0xAB, "{x}"); 18 | test(0xAB, "{#x}"); 19 | test(0xAB, "{X}"); 20 | test(0xAB, "{#X}"); 21 | } 22 | ################################################################################ 23 | # 171 24 | # 171 25 | # 10101011 26 | # 0b10101011 27 | # 253 28 | # 0o253 29 | # ab 30 | # 0xab 31 | # AB 32 | # 0xAB 33 | -------------------------------------------------------------------------------- /tests/std-byte-max.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | sys::dump[[byte]](byte::max(0xAAy, 0xBBy)); 6 | sys::dump[[byte]](byte::max(0xBBy, 0xAAy)); 7 | sys::dump[[byte]](byte::max(0xAAy, 0xAAy)); 8 | } 9 | ################################################################################ 10 | # BB 11 | # BB 12 | # AA 13 | -------------------------------------------------------------------------------- /tests/std-byte-min.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | sys::dump[[byte]](byte::min(0xAAy, 0xBBy)); 6 | sys::dump[[byte]](byte::min(0xBBy, 0xAAy)); 7 | sys::dump[[byte]](byte::min(0xAAy, 0xAAy)); 8 | } 9 | ################################################################################ 10 | # AA 11 | # AA 12 | # AA 13 | -------------------------------------------------------------------------------- /tests/std-cstr-count.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var count = std::cstr::count(&"\0"[0]); 5 | std::print_format_line(std::err(), "count = {}", (:[]std::formatter)[std::formatter::init[[typeof(count)]](&count)]); 6 | 7 | var count = std::cstr::count(&"123\0"[0]); 8 | std::print_format_line(std::err(), "count = {}", (:[]std::formatter)[std::formatter::init[[typeof(count)]](&count)]); 9 | } 10 | ################################################################################ 11 | # count = 0 12 | # count = 3 13 | -------------------------------------------------------------------------------- /tests/std-error-check-for-specific-error-info.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var result = ssize::init_from_str("123", 0xDEADBEEF); 5 | assert result.error() == std::error::INVALID_ARGUMENT; 6 | assert result.error() != std::error::PARSE_FAILURE; 7 | 8 | var result = ssize::init_from_str("bad string", 0); 9 | assert result.error() == std::error::PARSE_FAILURE; 10 | assert result.error() != std::error::INVALID_ARGUMENT; 11 | } 12 | -------------------------------------------------------------------------------- /tests/std-file-create-and-remove.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var result = std::file::create("some-file.tmp"); 5 | assert result.is_value(); 6 | var result = std::file::open("some-file.tmp", std::file::OPEN_READ); 7 | assert result.is_value(); 8 | var result = std::file::remove("some-file.tmp"); 9 | assert result.is_value(); 10 | var result = std::file::open("some-file.tmp", std::file::OPEN_READ); 11 | assert result.is_error(); 12 | } 13 | -------------------------------------------------------------------------------- /tests/std-file-open-write-and-append.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | let path: []byte = "data.tmp"; 4 | 5 | func main() void { 6 | var result = std::file::open(path, std::file::OPEN_WRITE | std::file::OPEN_APPEND); 7 | std::print_line(std::err(), result.error().*.data); 8 | } 9 | ################################################################################ 10 | # invalid argument 11 | -------------------------------------------------------------------------------- /tests/std-file-read-and-write.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | let path: []byte = "data.tmp"; 5 | 6 | func main() void { 7 | var result = std::file::open(path, std::file::OPEN_READ | std::file::OPEN_WRITE); 8 | var file = result.value(); 9 | 10 | var reader = std::reader::init[[std::file]](&file); 11 | var writer = std::writer::init[[std::file]](&file); 12 | std::print_line(writer, "SOME TEXT"); 13 | 14 | file.seek(0, std::file::SEEK_START); 15 | var buf = (:[512]byte)[0...]; 16 | var result = reader.read(buf[0:countof(buf)]); 17 | std::print_line(std::out(), buf[0:result.value()]); 18 | file.close(); 19 | } 20 | ################################################################################ 21 | # SOME TEXT 22 | -------------------------------------------------------------------------------- /tests/std-file-read.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var result = std::file::open("data.txt", std::file::OPEN_READ); 5 | var file = result.value(); 6 | var reader = std::reader::init[[std::file]](&file); 7 | var buf = (:[512]byte)[0...]; 8 | var result = reader.read(buf[0:countof(buf)]); 9 | std::print(std::out(), buf[0:result.value()]); 10 | file.close(); 11 | } 12 | ################################################################################ 13 | # TEST DATA FILE LINE 1 14 | # TEST DATA FILE LINE 2 15 | -------------------------------------------------------------------------------- /tests/std-file-write-to-bad-fd.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var file = (:std::file){._fd = -1}; 5 | var result = file.write("nope"); 6 | std::print_line(std::out(), result.error().*.data); 7 | } 8 | ################################################################################ 9 | # [system error EBADF] Bad file descriptor 10 | -------------------------------------------------------------------------------- /tests/std-file.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var file: std::file = (:std::file){._fd = sys::STDOUT_FILENO}; 6 | file.write("Hello, file!\n"); 7 | 8 | var writer: std::writer = std::writer::init[[std::file]](&file); 9 | writer.write("Hello, file_writer!\n"); 10 | } 11 | ################################################################################ 12 | # Hello, file! 13 | # Hello, file_writer! 14 | -------------------------------------------------------------------------------- /tests/std-int-abs.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var x = s32::abs(+123); 5 | var y = s32::abs(-123); 6 | std::print_format_line( 7 | std::out(), 8 | "{} {}", 9 | (:[]std::formatter)[ 10 | std::formatter::init[[typeof(x)]](&x), 11 | std::formatter::init[[typeof(y)]](&y)]); 12 | 13 | var x = ssize::abs(+123); 14 | var y = ssize::abs(-123); 15 | std::print_format_line( 16 | std::out(), 17 | "{} {}", 18 | (:[]std::formatter)[ 19 | std::formatter::init[[typeof(x)]](&x), 20 | std::formatter::init[[typeof(y)]](&y)]); 21 | } 22 | ################################################################################ 23 | # 123 123 24 | # 123 123 25 | -------------------------------------------------------------------------------- /tests/std-new-delete-with-allocator.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var allocator = std::global_allocator(); 5 | var ptr: *u16 = std::new_with_allocator[[u16]](allocator); 6 | *ptr = 0xBEEF; # Touch the memory to make sure we were allocated a valid page. 7 | std::delete_with_allocator[[u16]](allocator, ptr); 8 | } 9 | -------------------------------------------------------------------------------- /tests/std-new-delete.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var ptr: *u16 = std::new[[u16]](); 5 | *ptr = 0xBEEF; # Touch the memory to make sure we were allocated a valid chunk. 6 | std::delete[[u16]](ptr); 7 | } 8 | -------------------------------------------------------------------------------- /tests/std-null.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | # Ensure that std::NULL can be used in comparisons. 5 | std::NULL == std::NULL; 6 | std::ptr[[byte]]::NULL == std::NULL; 7 | std::NULL == std::ptr[[byte]]::NULL; 8 | if foo() != std::NULL { 9 | # then do something... 10 | } 11 | 12 | # Conversion from *any to *T still requires casting. 13 | bar((:*ssize)std::NULL); 14 | } 15 | 16 | func foo() *ssize { 17 | return (:*ssize)123u; # pretend we allocate... 18 | } 19 | 20 | func bar(ptr_: *ssize) void { 21 | # do nothing... 22 | } 23 | -------------------------------------------------------------------------------- /tests/std-null_allocator-allocate.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var result = std::null_allocator::the().*.allocate(0, 0); 5 | std::print_line(std::err(), result.error().*.data); 6 | } 7 | ################################################################################ 8 | # allocation failure 9 | -------------------------------------------------------------------------------- /tests/std-null_allocator-constants.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var _ = std::string::init_with_allocator(std::null_allocator::ALLOCATOR); 5 | } 6 | -------------------------------------------------------------------------------- /tests/std-null_allocator-deallocate.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | std::null_allocator::the().*.deallocate((:*byte)0u, 0, 0); 5 | } 6 | ################################################################################ 7 | # panic: attempted null_allocator deallocation 8 | -------------------------------------------------------------------------------- /tests/std-null_allocator-reallocate.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | std::null_allocator::the().*.reallocate((:*byte)0u, 0, 0, 0); 5 | } 6 | ################################################################################ 7 | # panic: attempted null_allocator reallocation 8 | -------------------------------------------------------------------------------- /tests/std-null_allocator-the.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var _ = std::string::init_with_allocator(std::allocator::init[[std::null_allocator]](std::null_allocator::the())); 5 | } 6 | -------------------------------------------------------------------------------- /tests/std-optional-constant.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var a: std::optional[[u16]] = std::optional[[u16]]::EMPTY; 5 | assert not a.is_value(); 6 | assert a.is_empty(); 7 | a.value(); # boom 8 | } 9 | ################################################################################ 10 | # panic: attempted to retrieve value from empty std::optional 11 | -------------------------------------------------------------------------------- /tests/std-optional-init-empty.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var a: std::optional[[u16]] = std::optional[[u16]]::init_empty(); 5 | assert not a.is_value(); 6 | assert a.is_empty(); 7 | a.value(); # boom 8 | } 9 | ################################################################################ 10 | # panic: attempted to retrieve value from empty std::optional 11 | -------------------------------------------------------------------------------- /tests/std-optional-init-value.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var a: std::optional[[u16]] = std::optional[[u16]]::init_value(0xBEEF); 6 | assert a.is_value(); 7 | assert not a.is_empty(); 8 | sys::dump[[u16]](a.value()); 9 | } 10 | ################################################################################ 11 | # EF BE 12 | -------------------------------------------------------------------------------- /tests/std-panic_format.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var int: usize = 42; 5 | std::panic_format( 6 | "foo bar {}", 7 | (:[]std::formatter)[std::formatter::init[[usize]](&int)]); 8 | } 9 | ################################################################################ 10 | # panic: foo bar 42 11 | -------------------------------------------------------------------------------- /tests/std-ptr-null.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | struct foo { 5 | var a: u32; 6 | var b: s32; 7 | } 8 | 9 | func main() void { 10 | assert (:usize)std::ptr[[u8]]::NULL == 0; 11 | assert (:usize)std::ptr[[u16]]::NULL == 0; 12 | assert (:usize)std::ptr[[u32]]::NULL == 0; 13 | assert (:usize)std::ptr[[u64]]::NULL == 0; 14 | assert (:usize)std::ptr[[foo]]::NULL == 0; 15 | 16 | var x: u16 = 0xBEEF; 17 | var y: u32 = 0xCAFEF00D; 18 | 19 | assert std::ptr[[u16]]::NULL != &x; 20 | assert std::ptr[[u32]]::NULL != &y; 21 | } 22 | -------------------------------------------------------------------------------- /tests/std-read_all.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var open_result = std::file::open("data.txt", std::file::OPEN_READ); 5 | var file: std::file = open_result.value(); 6 | 7 | var reader = std::reader::init[[std::file]](&file); 8 | 9 | var read_result = std::read_all(reader); 10 | var bytes = read_result.value(); 11 | std::print(std::out(), bytes); 12 | 13 | std::slice[[byte]]::delete(bytes); 14 | file.close(); 15 | } 16 | ################################################################################ 17 | # TEST DATA FILE LINE 1 18 | # TEST DATA FILE LINE 2 19 | -------------------------------------------------------------------------------- /tests/std-read_all_with_allocator.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var open_result = std::file::open("data.txt", std::file::OPEN_READ); 5 | var file: std::file = open_result.value(); 6 | 7 | var reader = std::reader::init[[std::file]](&file); 8 | var allocator = std::global_allocator(); 9 | 10 | var read_result = std::read_all_with_allocator(allocator, reader); 11 | var bytes = read_result.value(); 12 | std::print(std::out(), bytes); 13 | 14 | std::slice[[byte]]::delete_with_allocator(allocator, bytes); 15 | file.close(); 16 | } 17 | ################################################################################ 18 | # TEST DATA FILE LINE 1 19 | # TEST DATA FILE LINE 2 20 | -------------------------------------------------------------------------------- /tests/std-result-init-error.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var a: std::result[[void, u16]] = std::result[[void, u16]]::init_error(0xBEEF); 6 | assert not a.is_value(); 7 | assert a.is_error(); 8 | sys::dump[[u16]](a.error()); 9 | a.value(); # boom 10 | } 11 | ################################################################################ 12 | # EF BE 13 | # panic: attempted to retrieve value from std::result in the error state 14 | -------------------------------------------------------------------------------- /tests/std-result-init-value.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var a: std::result[[u16, void]] = std::result[[u16, void]]::init_value(0xBEEF); 6 | assert a.is_value(); 7 | assert not a.is_error(); 8 | sys::dump[[u16]](a.value()); 9 | a.error(); # boom 10 | } 11 | ################################################################################ 12 | # EF BE 13 | # panic: attempted to retrieve error from std::result in the value state 14 | -------------------------------------------------------------------------------- /tests/std-slice-fill.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var a: [5]byte = (:[5]byte)[0xAA, 0xBB, 0xCC, 0xDD, 0xEE]; 6 | std::slice[[byte]]::fill(a[0:countof(a)], 0xFF); 7 | sys::dump[[[5]byte]](a); 8 | std::slice[[byte]]::fill(a[0:countof(a)], 0xAA); 9 | sys::dump[[[5]byte]](a); 10 | 11 | # Test with non-8-bit type. 12 | var b: [5]u16 = (:[5]u16)[0xAAAA, 0xBBBB, 0xCCCC, 0xDDDD, 0xEEEE]; 13 | std::slice[[u16]]::fill(b[0:countof(b)], 0xFFFF); 14 | sys::dump[[[5]u16]](b); 15 | } 16 | ################################################################################ 17 | # FF FF FF FF FF 18 | # AA AA AA AA AA 19 | # FF FF FF FF FF FF FF FF FF FF 20 | -------------------------------------------------------------------------------- /tests/std-slice-new-resize-delete-with-allocator.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var allocator = std::global_allocator(); 5 | 6 | var slice: []u16 = std::slice[[u16]]::new_with_allocator(allocator, 2048); 7 | for i in 0:countof(slice) { 8 | slice[i] = 0xBEEF; 9 | } 10 | 11 | slice = std::slice[[u16]]::resize_with_allocator(allocator, slice, 4096); 12 | for i in 0:countof(slice) { 13 | slice[i] = 0xF00D; 14 | } 15 | 16 | slice = std::slice[[u16]]::resize_with_allocator(allocator, slice, 1000); 17 | for i in 0:countof(slice) { 18 | slice[i] = 0xCAFE; 19 | } 20 | 21 | std::slice[[u16]]::delete_with_allocator(allocator, slice); 22 | } 23 | -------------------------------------------------------------------------------- /tests/std-slice-new-resize-delete.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var slice: []u16 = std::slice[[u16]]::new(2048); 5 | for i in 0:countof(slice) { 6 | slice[i] = 0xBEEF; 7 | } 8 | 9 | slice = std::slice[[u16]]::resize(slice, 4096); 10 | for i in 0:countof(slice) { 11 | slice[i] = 0xF00D; 12 | } 13 | 14 | slice = std::slice[[u16]]::resize(slice, 1000); 15 | for i in 0:countof(slice) { 16 | slice[i] = 0xCAFE; 17 | } 18 | 19 | std::slice[[u16]]::delete(slice); 20 | } 21 | -------------------------------------------------------------------------------- /tests/std-sort_with_comparator.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func compare_reverse[[T]](lhs: *T, rhs: *T) ssize { 4 | var cmp = T::compare(lhs, rhs); 5 | if cmp < 0 { 6 | return +1; 7 | } 8 | if cmp > 0 { 9 | return -1; 10 | } 11 | return 0; 12 | } 13 | 14 | func main() void { 15 | var x = (:[][]byte)["apple", "banana", "carrot"]; 16 | std::sort_with_comparator[[[]byte]](x, compare_reverse[[[]byte]]); 17 | for i in countof(x) { 18 | std::print_format_line(std::out(), "{}", (:[]std::formatter)[std::formatter::init[[[]byte]](&x[i])]); 19 | } 20 | } 21 | ################################################################################ 22 | # carrot 23 | # banana 24 | # apple 25 | -------------------------------------------------------------------------------- /tests/std-str-ends_with.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | assert std::str::ends_with("", ""); 5 | assert std::str::ends_with("a", ""); 6 | assert not std::str::ends_with("", "a"); 7 | 8 | assert std::str::ends_with("foobar", "r"); 9 | assert std::str::ends_with("foobar", "ar"); 10 | assert std::str::ends_with("foobar", "bar"); 11 | assert not std::str::ends_with("foobar", "bbar"); 12 | assert not std::str::ends_with("foobar", "foo"); 13 | } 14 | -------------------------------------------------------------------------------- /tests/std-str-starts_with.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | assert std::str::starts_with("", ""); 5 | assert std::str::starts_with("a", ""); 6 | assert not std::str::starts_with("", "a"); 7 | 8 | assert std::str::starts_with("foobar", "f"); 9 | assert std::str::starts_with("foobar", "fo"); 10 | assert std::str::starts_with("foobar", "foo"); 11 | assert not std::str::starts_with("foobar", "fooo"); 12 | assert not std::str::starts_with("foobar", "bar"); 13 | } 14 | -------------------------------------------------------------------------------- /tests/std-string-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var string_a = std::string::init_from_str("the quick brown fox jumps over the lazy dog"); 5 | var string_b = std::string::init(); 6 | std::string::assign(&string_b, &string_a); 7 | assert std::str::eq(string_a.data(), string_b.data()); 8 | string_a.fini(); 9 | string_b.fini(); 10 | } 11 | -------------------------------------------------------------------------------- /tests/std-string-init.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var string = std::string::init(); 6 | defer string.fini(); 7 | 8 | sys::dump[[*byte]](string.start()); 9 | sys::dump[[usize]](string.count()); 10 | sys::dump[[usize]](string.capacity()); 11 | sys::dump[[[]byte]](string.data()); 12 | } 13 | ################################################################################ 14 | # 00 00 00 00 00 00 00 00 15 | # 00 00 00 00 00 00 00 00 16 | # 00 00 00 00 00 00 00 00 17 | # 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 | -------------------------------------------------------------------------------- /tests/std-string-init_assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var string_a = std::string::init_from_str("the quick brown fox jumps over the lazy dog"); 5 | var string_b = std::string::init_assign(&string_a); 6 | assert std::str::eq(string_a.data(), string_b.data()); 7 | string_a.fini(); 8 | string_b.fini(); 9 | } 10 | -------------------------------------------------------------------------------- /tests/std-string-init_from_format.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var x = 123u16; 5 | var y = "some str"; 6 | 7 | var string = std::string::init_from_format( 8 | "{} {}", 9 | (:[]std::formatter)[ 10 | std::formatter::init[[u16]](&x), 11 | std::formatter::init[[[]byte]](&y)]); 12 | defer string.fini(); 13 | 14 | var count = string.count(); 15 | std::print_format_line( 16 | std::out(), 17 | "count = {}", 18 | (:[]std::formatter)[std::formatter::init[[usize]](&count)]); 19 | 20 | std::print_line(std::out(), string.data()); 21 | } 22 | ################################################################################ 23 | # count = 12 24 | # 123 some str 25 | -------------------------------------------------------------------------------- /tests/std-string-init_from_str.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var string = std::string::init_from_str("foo bar"); 5 | defer string.fini(); 6 | 7 | var count = string.count(); 8 | std::print_format_line( 9 | std::out(), 10 | "count = {}", 11 | (:[]std::formatter)[std::formatter::init[[usize]](&count)]); 12 | 13 | std::print_line(std::out(), string.data()); 14 | } 15 | ################################################################################ 16 | # count = 7 17 | # foo bar 18 | -------------------------------------------------------------------------------- /tests/std-string-init_from_str_with_allocator.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var string = std::string::init_from_str_with_allocator(std::global_allocator(), "foo bar"); 5 | defer string.fini(); 6 | 7 | var count = string.count(); 8 | std::print_format_line( 9 | std::out(), 10 | "count = {}", 11 | (:[]std::formatter)[std::formatter::init[[usize]](&count)]); 12 | 13 | std::print_line(std::out(), string.data()); 14 | } 15 | ################################################################################ 16 | # count = 7 17 | # foo bar 18 | -------------------------------------------------------------------------------- /tests/std-string-init_with_allocator.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var string = std::string::init_with_allocator(std::global_allocator()); 6 | defer string.fini(); 7 | 8 | sys::dump[[*byte]](string.start()); 9 | sys::dump[[usize]](string.count()); 10 | sys::dump[[usize]](string.capacity()); 11 | sys::dump[[[]byte]](string.data()); 12 | } 13 | ################################################################################ 14 | # 00 00 00 00 00 00 00 00 15 | # 00 00 00 00 00 00 00 00 16 | # 00 00 00 00 00 00 00 00 17 | # 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 | -------------------------------------------------------------------------------- /tests/std-unreachable.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | std::unreachable(fileof(), lineof()); 5 | } 6 | ################################################################################ 7 | # [std-unreachable.test.sunder:4] unreachable 8 | -------------------------------------------------------------------------------- /tests/std-vector-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var vector_a = std::vector[[ssize]]::init(); 5 | var vector_b = std::vector[[ssize]]::init(); 6 | vector_a.push(123); 7 | vector_a.push(456); 8 | vector_a.push(789); 9 | std::vector[[ssize]]::assign(&vector_b, &vector_a); 10 | assert vector_a.count() == vector_b.count(); 11 | assert vector_a.data()[0] == vector_b.data()[0]; 12 | assert vector_a.data()[1] == vector_b.data()[1]; 13 | assert vector_a.data()[2] == vector_b.data()[2]; 14 | vector_a.fini(); 15 | vector_b.fini(); 16 | } 17 | -------------------------------------------------------------------------------- /tests/std-vector-element-fini-order.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct foo { 4 | var text: []byte; 5 | 6 | func init(text: []byte) foo { 7 | return (:foo){.text = text}; 8 | } 9 | 10 | func fini(self: *foo) void { 11 | std::print_line(std::out(), self.*.text); 12 | } 13 | } 14 | 15 | func main() void { 16 | var vec = std::vector[[foo]]::init(); 17 | vec.push(foo::init("a")); 18 | vec.push(foo::init("b")); 19 | vec.push(foo::init("c")); 20 | vec.push(foo::init("d")); 21 | vec.push(foo::init("e")); 22 | vec.push(foo::init("f")); 23 | vec.fini(); 24 | } 25 | ################################################################################ 26 | # a 27 | # b 28 | # c 29 | # d 30 | # e 31 | # f 32 | -------------------------------------------------------------------------------- /tests/std-vector-init.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var vec = std::vector[[u32]]::init(); 6 | defer vec.fini(); 7 | 8 | sys::dump[[*u32]](vec.start()); 9 | sys::dump[[usize]](vec.count()); 10 | sys::dump[[usize]](vec.capacity()); 11 | sys::dump[[[]u32]](vec.data()); 12 | } 13 | ################################################################################ 14 | # 00 00 00 00 00 00 00 00 15 | # 00 00 00 00 00 00 00 00 16 | # 00 00 00 00 00 00 00 00 17 | # 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 | -------------------------------------------------------------------------------- /tests/std-vector-init_assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var vector_a = std::vector[[ssize]]::init(); 5 | vector_a.push(123); 6 | vector_a.push(456); 7 | vector_a.push(789); 8 | var vector_b = std::vector[[ssize]]::init_assign(&vector_a); 9 | assert vector_a.count() == vector_b.count(); 10 | assert vector_a.data()[0] == vector_b.data()[0]; 11 | assert vector_a.data()[1] == vector_b.data()[1]; 12 | assert vector_a.data()[2] == vector_b.data()[2]; 13 | vector_a.fini(); 14 | vector_b.fini(); 15 | } 16 | -------------------------------------------------------------------------------- /tests/std-vector-init_with_allocator.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | import "sys"; 3 | 4 | func main() void { 5 | var vec = std::vector[[u32]]::init_with_allocator(std::global_allocator()); 6 | defer vec.fini(); 7 | 8 | sys::dump[[*u32]](vec.start()); 9 | sys::dump[[usize]](vec.count()); 10 | sys::dump[[usize]](vec.capacity()); 11 | sys::dump[[[]u32]](vec.data()); 12 | } 13 | ################################################################################ 14 | # 00 00 00 00 00 00 00 00 15 | # 00 00 00 00 00 00 00 00 16 | # 00 00 00 00 00 00 00 00 17 | # 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 | -------------------------------------------------------------------------------- /tests/std-vector-with-no-elements-added-does-not-allocate.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var vec = std::vector[[u32]]::init_with_allocator(std::allocator::init[[std::null_allocator]](std::null_allocator::the())); 5 | vec.fini(); 6 | } 7 | -------------------------------------------------------------------------------- /tests/std-void-format.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var v = void::VALUE; 5 | std::print_format_line( 6 | std::out(), 7 | "{}", 8 | (:[]std::formatter)[std::formatter::init[[void]](&v)]); 9 | } 10 | ################################################################################ 11 | # void 12 | -------------------------------------------------------------------------------- /tests/std-write_all.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func main() void { 4 | var result = std::write_all(std::out(), "Call to write_all (stdout)!\n"); 5 | assert result.is_value(); 6 | 7 | var result = std::write_all(std::err(), "Call to write_all (stderr)!\n"); 8 | assert result.is_value(); 9 | } 10 | ################################################################################ 11 | # Call to write_all (stdout)! 12 | # Call to write_all (stderr)! 13 | -------------------------------------------------------------------------------- /tests/std-write_format-ambiguous-rbrace.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct person { 4 | var name: []byte; 5 | 6 | func format(self: *person, writer: std::writer, fmt: []byte) std::result[[void, std::error]] { 7 | if countof(fmt) != 0 { 8 | return std::result[[void, std::error]]::init_error(std::error::INVALID_ARGUMENT); 9 | } 10 | return std::write_all(writer, self.*.name); 11 | } 12 | } 13 | 14 | func main() void { 15 | var alice: person = (:person){.name = "Alice"}; 16 | std::write_format(std::out(), "{}}}\n", (:[]std::formatter)[std::formatter::init[[person]](&alice)]); 17 | } 18 | ################################################################################ 19 | # panic: invalid format string "{}}}\n" 20 | -------------------------------------------------------------------------------- /tests/std-write_format-unmatched-lbrace.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct person { 4 | var name: []byte; 5 | 6 | func format(self: *person, writer: std::writer, fmt: []byte) std::result[[void, std::error]] { 7 | if countof(fmt) != 0 { 8 | return std::result[[void, std::error]]::init_error(std::error::INVALID_ARGUMENT); 9 | } 10 | return std::write_all(writer, self.*.name); 11 | } 12 | } 13 | 14 | func main() void { 15 | var alice: person = (:person){.name = "Alice"}; 16 | std::write_format(std::out(), "baz{qux", (:[]std::formatter)[std::formatter::init[[person]](&alice)]); 17 | } 18 | ################################################################################ 19 | # bazpanic: invalid format string "baz{qux" 20 | -------------------------------------------------------------------------------- /tests/std-write_format-unmatched-rbrace.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct person { 4 | var name: []byte; 5 | 6 | func format(self: *person, writer: std::writer, fmt: []byte) std::result[[void, std::error]] { 7 | if countof(fmt) != 0 { 8 | return std::result[[void, std::error]]::init_error(std::error::INVALID_ARGUMENT); 9 | } 10 | return std::write_all(writer, self.*.name); 11 | } 12 | } 13 | 14 | func main() void { 15 | var alice: person = (:person){.name = "Alice"}; 16 | std::write_format(std::out(), "baz}qux", (:[]std::formatter)[std::formatter::init[[person]](&alice)]); 17 | } 18 | ################################################################################ 19 | # panic: invalid format string "baz}qux" 20 | -------------------------------------------------------------------------------- /tests/stmt-add-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | import "std"; 3 | 4 | func main() void { 5 | var x = 0xAAu8; 6 | x += 2; 7 | sys::dump[[typeof(x)]](x); 8 | 9 | var y = 1.0f32; 10 | y += 2.0; 11 | std::print_format_line(std::err(), "{.1}", (:[]std::formatter)[std::formatter::init[[typeof(y)]](&y)]); 12 | } 13 | ################################################################################ 14 | # AC 15 | # 3.0 16 | -------------------------------------------------------------------------------- /tests/stmt-add-wrapping-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x = 0xFFu8; 5 | x +%= 2; 6 | sys::dump[[typeof(x)]](x); 7 | } 8 | ################################################################################ 9 | # 01 10 | -------------------------------------------------------------------------------- /tests/stmt-assert.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | assert 123 < 456; 3 | assert 123 > 456; 4 | } 5 | ################################################################################ 6 | # [stmt-assert.test.sunder:3] assertion failure 7 | # assert 123 > 456; 8 | -------------------------------------------------------------------------------- /tests/stmt-bitand-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x = 0x0Fu8; 5 | x &= 0xF1; 6 | sys::dump[[typeof(x)]](x); 7 | } 8 | ################################################################################ 9 | # 01 10 | -------------------------------------------------------------------------------- /tests/stmt-bitor-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x = 0x0Fu8; 5 | x |= 0xF0; 6 | sys::dump[[typeof(x)]](x); 7 | } 8 | ################################################################################ 9 | # FF 10 | -------------------------------------------------------------------------------- /tests/stmt-bitxor-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x = 0x0Fu8; 5 | x ^= 0xF1; 6 | sys::dump[[typeof(x)]](x); 7 | } 8 | ################################################################################ 9 | # FE 10 | -------------------------------------------------------------------------------- /tests/stmt-break.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | for true { 5 | for i in 1u:5u { 6 | if i == 3u { 7 | break; 8 | } 9 | sys::dump[[usize]](i); 10 | } 11 | 12 | break; 13 | sys::dump[[u32]](0xDEADBEEFu32); 14 | } 15 | } 16 | ################################################################################ 17 | # 01 00 00 00 00 00 00 00 18 | # 02 00 00 00 00 00 00 00 19 | -------------------------------------------------------------------------------- /tests/stmt-continue.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x: usize = 1u; 5 | for x != 0u { 6 | for i in 1u:5u { 7 | if i < 3u { 8 | continue; 9 | } 10 | sys::dump[[usize]](i); 11 | } 12 | 13 | x = 0u; 14 | continue; 15 | sys::dump[[u32]](0xDEADBEEFu32); 16 | } 17 | } 18 | ################################################################################ 19 | # 03 00 00 00 00 00 00 00 20 | # 04 00 00 00 00 00 00 00 21 | -------------------------------------------------------------------------------- /tests/stmt-div-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | import "std"; 3 | 4 | func main() void { 5 | var x = 5u8; 6 | x /= 2; 7 | sys::dump[[typeof(x)]](x); 8 | 9 | var y = 3.0f32; 10 | y /= 2.0; 11 | std::print_format_line(std::err(), "{.1}", (:[]std::formatter)[std::formatter::init[[typeof(y)]](&y)]); 12 | } 13 | ################################################################################ 14 | # 02 15 | # 1.5 16 | -------------------------------------------------------------------------------- /tests/stmt-for-expr.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var n: usize = 3u; 5 | for n != 7u { 6 | sys::dump[[usize]](n); 7 | n = n + 1u; 8 | } 9 | 10 | } 11 | ################################################################################ 12 | # 03 00 00 00 00 00 00 00 13 | # 04 00 00 00 00 00 00 00 14 | # 05 00 00 00 00 00 00 00 15 | # 06 00 00 00 00 00 00 00 16 | -------------------------------------------------------------------------------- /tests/stmt-mul-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | import "std"; 3 | 4 | func main() void { 5 | var x = 0x11u8; 6 | x *= 2; 7 | sys::dump[[typeof(x)]](x); 8 | 9 | var y = 2.0f32; 10 | y *= 3.0; 11 | std::print_format_line(std::err(), "{.1}", (:[]std::formatter)[std::formatter::init[[typeof(y)]](&y)]); 12 | } 13 | ################################################################################ 14 | # 22 15 | # 6.0 16 | -------------------------------------------------------------------------------- /tests/stmt-mul-wrapping-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x = 0xAAu8; 5 | x *%= 2; 6 | sys::dump[[typeof(x)]](x); 7 | } 8 | ################################################################################ 9 | # 54 10 | -------------------------------------------------------------------------------- /tests/stmt-rem-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x = 5u8; 5 | x %= 2; 6 | sys::dump[[typeof(x)]](x); 7 | } 8 | ################################################################################ 9 | # 01 10 | -------------------------------------------------------------------------------- /tests/stmt-return-void-with-side-effects.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | func f() void { 4 | std::print_line(std::out(), "HELLO"); 5 | } 6 | 7 | func g() void { 8 | return f(); 9 | } 10 | 11 | func h() void { 12 | return f(); 13 | } 14 | 15 | func main() void { 16 | return g(); 17 | } 18 | ################################################################################ 19 | # HELLO 20 | -------------------------------------------------------------------------------- /tests/stmt-return-void.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | return; 3 | } 4 | -------------------------------------------------------------------------------- /tests/stmt-shiftl-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x = 0x01u8 ; 5 | x <<= 1u; 6 | sys::dump[[typeof(x)]](x); 7 | 8 | var x = -1s8; 9 | x = x << 1u; 10 | sys::dump[[typeof(x)]](x); 11 | 12 | # Check implicit casts from an integer rhs to usize. 13 | 14 | var x = 0x01u8 ; 15 | x <<= 1u; 16 | sys::dump[[typeof(x)]](x); 17 | 18 | var x = -1s8; 19 | x <<= 1; 20 | sys::dump[[typeof(x)]](x); 21 | } 22 | ################################################################################ 23 | # 02 24 | # FE 25 | # 02 26 | # FE 27 | -------------------------------------------------------------------------------- /tests/stmt-sub-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | import "std"; 3 | 4 | func main() void { 5 | var x = 0xAAu8; 6 | x -= 2; 7 | sys::dump[[typeof(x)]](x); 8 | 9 | var y = 1.0f32; 10 | y -= 2.0; 11 | std::print_format_line(std::err(), "{.1}", (:[]std::formatter)[std::formatter::init[[typeof(y)]](&y)]); 12 | } 13 | ################################################################################ 14 | # A8 15 | # -1.0 16 | -------------------------------------------------------------------------------- /tests/stmt-sub-wrapping-assign.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | var x = 0x00u8; 5 | x -%= 2; 6 | sys::dump[[typeof(x)]](x); 7 | } 8 | ################################################################################ 9 | # FE 10 | -------------------------------------------------------------------------------- /tests/sunder-test-7-hashes.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { } 2 | ####### 3 | # Eight or more hashes are required for the expected output delimiter, so this 4 | # sentence is not considered expected output. 5 | -------------------------------------------------------------------------------- /tests/sunder-test-8-hashes.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | sys::dump[[u8]](0x01); 5 | } 6 | ######## 7 | # 01 8 | -------------------------------------------------------------------------------- /tests/sunder-test-9-hashes.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func main() void { 4 | sys::dump[[u8]](0x01); 5 | } 6 | ######### 7 | # 01 8 | -------------------------------------------------------------------------------- /tests/symbol-starts-with-type.test.sunder: -------------------------------------------------------------------------------- 1 | import "std"; 2 | 3 | struct foo { 4 | var variable: usize; 5 | let CONSTANT = 0xBEEFu16; 6 | } 7 | 8 | func main() void { 9 | var f = (:foo){.variable = 123}; 10 | typeof(f)::CONSTANT; 11 | std::print_format_line(std::out(), "{#X}", (:[]std::formatter)[std::formatter::init[[u16]](&typeof(f)::CONSTANT)]); 12 | } 13 | ################################################################################ 14 | # 0xBEEF 15 | -------------------------------------------------------------------------------- /tests/sys-dump.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | func foo() void { 4 | # this function does nothing 5 | } 6 | 7 | func main() void { 8 | sys::dump[[bool]](true); 9 | sys::dump[[bool]](false); 10 | sys::dump[[usize]](0xAAu); 11 | sys::dump[[usize]](0xABCDu); 12 | sys::dump[[void]](foo()); 13 | sys::dump[[usize]](0x76543210u); 14 | sys::dump[[usize]](0xDEADBEEFu); 15 | sys::dump[[usize]](0xBADCAFE01DC0FFEEu); 16 | } 17 | ################################################################################ 18 | # 01 19 | # 00 20 | # AA 00 00 00 00 00 00 00 21 | # CD AB 00 00 00 00 00 00 22 | # 23 | # 10 32 54 76 00 00 00 00 24 | # EF BE AD DE 00 00 00 00 25 | # EE FF C0 1D E0 AF DC BA 26 | -------------------------------------------------------------------------------- /tests/sys-max-align.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | func main() void { 3 | # Ensure that sys::MAX_ALIGN is defined on all platforms. 4 | assert defined(sys::MAX_ALIGN); 5 | # Ensure that sys::MAX_ALIGN is of type usize. 6 | sys::MAX_ALIGN == 0u; 7 | } 8 | -------------------------------------------------------------------------------- /tests/type-symbol-starting-with-scope-resolution-operator.test.sunder: -------------------------------------------------------------------------------- 1 | func main() void { 2 | var _: ::bool = true; 3 | var _: ::u32 = 123; 4 | } 5 | -------------------------------------------------------------------------------- /tests/type-union.test.sunder: -------------------------------------------------------------------------------- 1 | import "sys"; 2 | 3 | let a: union { var x: u16; var y: u32; } = (:union { var x: u16; var y: u32; }){.x = 0xAAAAu16}; 4 | var b: union { 5 | var x: union { var foo: ssize; }; 6 | var y: union { var foo: ssize; }; 7 | } = uninit; 8 | 9 | func main() void { 10 | sys::dump[[union { var x: u16; var y: u32; }]](a); 11 | sys::dump[[typeof(b)]](b); 12 | } 13 | ################################################################################ 14 | # AA AA 00 00 15 | # 00 00 00 00 00 00 00 00 16 | -------------------------------------------------------------------------------- /tests/util/argv.sunder: -------------------------------------------------------------------------------- 1 | namespace util::argv; 2 | import "std"; 3 | 4 | # Transform the provided arguments into an C-style argument vector. 5 | func new(arguments: [][]byte) **byte { 6 | var args = std::slice[[*byte]]::new(countof(arguments) + 1); 7 | for i in countof(arguments) { 8 | var str = std::slice[[byte]]::new(countof(arguments[i]) + 1); 9 | std::slice[[byte]]::copy(str[0:countof(arguments[i])], arguments[i]); 10 | str[countof(arguments[i])] = '\0'; 11 | args[i] = &str[0]; 12 | } 13 | args[countof(arguments)] = std::ptr[[byte]]::NULL; 14 | return &args[0]; 15 | } 16 | -------------------------------------------------------------------------------- /tests/warning-stmt-assign-lhs-is-constant.sunder: -------------------------------------------------------------------------------- 1 | func constant_bytes () void { 2 | "abc" = "123"; 3 | } 4 | 5 | func constant_symbol () void { 6 | let x = 123s; 7 | x = 456; 8 | } 9 | 10 | func main() void { 11 | # This Sunder program is valid syntactically, but *should* crash at runtime 12 | # if any of the above functions are called. 13 | } 14 | ################################################################################ 15 | # [warning-stmt-assign-lhs-is-constant.sunder:2] warning: left hand side of assignment statement is a constant 16 | # "abc" = "123"; 17 | # ^ 18 | # [warning-stmt-assign-lhs-is-constant.sunder:7] warning: left hand side of assignment statement is a constant 19 | # x = 456; 20 | # ^ 21 | --------------------------------------------------------------------------------