d: Import dmd b8384668f, druntime e6caaab9, phobos 5ab9ad256 (v2.098.0-beta.1)

The D front-end is now itself written in D, in order to build GDC, you
will need a working GDC compiler (GCC version 9.1 or later).

GCC changes:

    - Add support for bootstrapping the D front-end.

These add the required components in order to have a D front-end written
in D itself.  Because the compiler front-end only depends on the core
runtime modules, only libdruntime is built for the bootstrap stages.

D front-end changes:

    - Import dmd v2.098.0-beta.1.

Druntime changes:

    - Import druntime v2.098.0-beta.1.

Phobos changes:

    - Import phobos v2.098.0-beta.1.

The jump from v2.076.1 to v2.098.0 covers nearly 4 years worth of
development on the D programming language and run-time libraries.

ChangeLog:

	* Makefile.def: Add bootstrap to libbacktrace, libphobos, zlib, and
	libatomic.
	* Makefile.in: Regenerate.
	* Makefile.tpl (POSTSTAGE1_HOST_EXPORTS): Fix command for GDC.
	(STAGE1_CONFIGURE_FLAGS): Add --with-libphobos-druntime-only if
	target-libphobos-bootstrap.
	(STAGE2_CONFIGURE_FLAGS): Likewise.
	* configure: Regenerate.
	* configure.ac: Add support for bootstrapping D front-end.

config/ChangeLog:

	* acx.m4 (ACX_PROG_GDC): New m4 function.

gcc/ChangeLog:

	* Makefile.in (GDC): New variable.
	(GDCFLAGS): New variable.
	* configure: Regenerate.
	* configure.ac: Add call to ACX_PROG_GDC.  Substitute GDCFLAGS.

gcc/d/ChangeLog:

	* dmd/MERGE: Merge upstream dmd b8384668f.
	* Make-lang.in (d-warn): Use strict warnings.
	(DMD_WARN_CXXFLAGS): Remove.
	(DMD_COMPILE): Remove.
	(CHECKING_DFLAGS): Define.
	(WARN_DFLAGS): Define.
	(ALL_DFLAGS): Define.
	(DCOMPILE.base): Define.
	(DCOMPILE): Define.
	(DPOSTCOMPILE): Define.
	(DLINKER): Define.
	(DLLINKER): Define.
	(D_FRONTEND_OBJS): Add new dmd front-end objects.
	(D_GENERATED_SRCS): Remove.
	(D_GENERATED_OBJS): Remove.
	(D_ALL_OBJS): Remove D_GENERATED_OBJS.
	(d21$(exeext)): Build using DLLINKER and -static-libphobos.
	(d.tags): Remove dmd/*.c and dmd/root/*.c.
	(d.mostlyclean): Remove D_GENERATED_SRCS, d/idgen$(build_exeext),
	d/impcnvgen$(build_exeext).
	(D_INCLUDES): Include $(srcdir)/d/dmd/res.
	(CFLAGS-d/id.o): Remove.
	(CFLAGS-d/impcnvtab.o): Remove.
	(d/%.o): Build using DCOMPILE and DPOSTCOMPILE.  Update dependencies
	from d/dmd/%.c to d/dmd/%.d.
	(d/idgen$(build_exeext)): Remove.
	(d/impcnvgen$(build_exeext)): Remove.
	(d/id.c): Remove.
	(d/id.h): Remove.
	(d/impcnvtab.c): Remove.
	(d/%.dmdgen.o): Remove.
	(D_SYSTEM_H): Remove.
	(d/idgen.dmdgen.o): Remove.
	(d/impcnvgen.dmdgen.o): Remove.
	* config-lang.in (boot_language): New variable.
	* d-attribs.cc: Include dmd/expression.h.
	* d-builtins.cc: Include d-frontend.h.
	(build_frontend_type): Update for new front-end interface.
	(d_eval_constant_expression): Likewise.
	(d_build_builtins_module): Likewise.
	(maybe_set_builtin_1): Likewise.
	(d_build_d_type_nodes): Likewise.
	* d-codegen.cc (d_decl_context): Likewise.
	(declaration_reference_p): Likewise.
	(declaration_type): Likewise.
	(parameter_reference_p): Likewise.
	(parameter_type): Likewise.
	(get_array_length): Likewise.
	(build_delegate_cst): Likewise.
	(build_typeof_null_value): Likewise.
	(identity_compare_p): Likewise.
	(lower_struct_comparison): Likewise.
	(build_filename_from_loc): Likewise.
	(build_assert_call): Remove LIBCALL_SWITCH_ERROR.
	(build_bounds_index_condition): Call LIBCALL_ARRAYBOUNDS_INDEXP on
	bounds error.
	(build_bounds_slice_condition): Call LIBCALL_ARRAYBOUNDS_SLICEP on
	bounds error.
	(array_bounds_check): Update for new front-end interface.
	(checkaction_trap_p): Handle CHECKACTION_context.
	(get_function_type): Update for new front-end interface.
	(d_build_call): Likewise.
	* d-compiler.cc: Remove include of dmd/scope.h.
	(Compiler::genCmain): Remove.
	(Compiler::paintAsType): Update for new front-end interface.
	(Compiler::onParseModule): Likewise.
	* d-convert.cc (convert_expr): Remove call to LIBCALL_ARRAYCAST.
	(convert_for_rvalue): Update for new front-end interface.
	(convert_for_assignment): Likewise.
	(convert_for_condition): Likewise.
	(d_array_convert): Likewise.
	* d-diagnostic.cc (error): Remove.
	(errorSupplemental): Remove.
	(warning): Remove.
	(warningSupplemental): Remove.
	(deprecation): Remove.
	(deprecationSupplemental): Remove.
	(message): Remove.
	(vtip): New.
	* d-frontend.cc (global): Remove.
	(Global::_init): Remove.
	(Global::startGagging): Remove.
	(Global::endGagging): Remove.
	(Global::increaseErrorCount): Remove.
	(Loc::Loc): Remove.
	(Loc::toChars): Remove.
	(Loc::equals): Remove.
	(isBuiltin): Update for new front-end interface.
	(eval_builtin): Likewise.
	(getTypeInfoType): Likewise.
	(inlineCopy): Remove.
	* d-incpath.cc: Include d-frontend.h.
	(add_globalpaths): Call d_gc_malloc to allocate Strings.
	(add_filepaths): Likewise.
	* d-lang.cc: Include dmd/id.h, dmd/root/file.h, d-frontend.h.  Remove
	include of dmd/mars.h, id.h.
	(entrypoint_module): Remove.
	(entrypoint_root_module): Remove.
	(deps_write_string): Update for new front-end interface.
	(deps_write): Likewise.
	(d_init_options): Call rt_init.  Remove setting global params that are
	default initialized by the front-end.
	(d_handle_option): Handle OPT_fcheckaction_, OPT_fdump_c___spec_,
	OPT_fdump_c___spec_verbose, OPT_fextern_std_, OPT_fpreview,
	OPT_revert, OPT_fsave_mixins_, and OPT_ftransition.
	(d_post_options): Propagate dip1021 and dip1000 preview flags to
	dip25, and flag_diagnostics_show_caret to printErrorContext.
	(d_add_entrypoint_module): Remove.
	(d_parse_file): Update for new front-end interface.
	(d_type_promotes_to): Likewise.
	(d_types_compatible_p): Likewise.
	* d-longdouble.cc (CTFloat::zero): Remove.
	(CTFloat::one): Remove.
	(CTFloat::minusone): Remove.
	(CTFloat::half): Remove.
	* d-system.h (POSIX): Remove.
	(realpath): Remove.
	(isalpha): Remove.
	(isalnum): Remove.
	(isdigit): Remove.
	(islower): Remove.
	(isprint): Remove.
	(isspace): Remove.
	(isupper): Remove.
	(isxdigit): Remove.
	(tolower): Remove.
	(_mkdir): Remove.
	(INT32_MAX): Remove.
	(INT32_MIN): Remove.
	(INT64_MIN): Remove.
	(UINT32_MAX): Remove.
	(UINT64_MAX): Remove.
	* d-target.cc: Include calls.h.
	(target): Remove.
	(define_float_constants): Remove initialization of snan.
	(Target::_init): Update for new front-end interface.
	(Target::isVectorTypeSupported): Likewise.
	(Target::isVectorOpSupported): Remove cases for unordered operators.
	(TargetCPP::typeMangle): Update for new front-end interface.
	(TargetCPP::parameterType): Likewise.
	(Target::systemLinkage): Likewise.
	(Target::isReturnOnStack): Likewise.
	(Target::isCalleeDestroyingArgs): Define.
	(Target::preferPassByRef): Define.
	* d-tree.h (d_add_entrypoint_module): Remove.
	* decl.cc (gcc_attribute_p): Update for new front-end interface.
	(apply_pragma_crt): Define.
	(DeclVisitor::visit(PragmaDeclaration *)): Handle pragmas
	crt_constructor and crt_destructor.
	(DeclVisitor::visit(TemplateDeclaration *)): Update for new front-end
	interface.
	(DeclVisitor::visit): Likewise.
	(DeclVisitor::finish_vtable): Likewise.
	(get_symbol_decl): Error if template has more than one nesting
	context.  Update for new front-end interface.
	(make_thunk): Update for new front-end interface.
	(get_vtable_decl): Likewise.
	* expr.cc (ExprVisitor::visit): Likewise.
	(build_return_dtor): Likewise.
	* imports.cc (ImportVisitor::visit): Likewise.
	* intrinsics.cc: Include dmd/expression.h.  Remove include of
	dmd/mangle.h.
	(maybe_set_intrinsic): Update for new front-end interface.
	* intrinsics.def (INTRINSIC_ROL): Update intrinsic signature.
	(INTRINSIC_ROR): Likewise.
	(INTRINSIC_ROR_TIARG): Likewise.
	(INTRINSIC_TOPREC): Likewise.
	(INTRINSIC_TOPRECL): Likewise.
	(INTRINSIC_TAN): Update intrinsic module and signature.
	(INTRINSIC_ISNAN): Likewise.
	(INTRINSIC_ISFINITE): Likewise.
	(INTRINSIC_COPYSIGN): Define intrinsic.
	(INTRINSIC_COPYSIGNI): Define intrinsic.
	(INTRINSIC_EXP): Update intrinsic module.
	(INTRINSIC_EXPM1): Likewise.
	(INTRINSIC_EXP2): Likewise.
	(INTRINSIC_LOG): Likewise.
	(INTRINSIC_LOG2): Likewise.
	(INTRINSIC_LOG10): Likewise.
	(INTRINSIC_POW): Likewise.
	(INTRINSIC_ROUND): Likewise.
	(INTRINSIC_FLOORF): Likewise.
	(INTRINSIC_FLOOR): Likewise.
	(INTRINSIC_FLOORL): Likewise.
	(INTRINSIC_CEILF): Likewise.
	(INTRINSIC_CEIL): Likewise.
	(INTRINSIC_CEILL): Likewise.
	(INTRINSIC_TRUNC): Likewise.
	(INTRINSIC_FMIN): Likewise.
	(INTRINSIC_FMAX): Likewise.
	(INTRINSIC_FMA): Likewise.
	(INTRINSIC_VA_ARG): Update intrinsic signature.
	(INTRINSIC_VASTART): Likewise.
	* lang.opt (fcheck=): Add alternate aliases for contract switches.
	(fcheckaction=): New option.
	(check_action): New Enum and EnumValue entries.
	(fdump-c++-spec-verbose): New option.
	(fdump-c++-spec=): New option.
	(fextern-std=): New option.
	(extern_stdcpp): New Enum and EnumValue entries
	(fpreview=): New options.
	(frevert=): New options.
	(fsave-mixins): New option.
	(ftransition=): Update options.
	* modules.cc (get_internal_fn): Replace Prot with Visibility.
	(build_internal_fn): Likewise.
	(build_dso_cdtor_fn): Likewise.
	(build_module_tree): Remove check for __entrypoint module.
	* runtime.def (P5): Define.
	(ARRAYBOUNDS_SLICEP): Define.
	(ARRAYBOUNDS_INDEXP): Define.
	(NEWTHROW): Define.
	(ADCMP2): Remove.
	(ARRAYCAST): Remove.
	(SWITCH_STRING): Remove.
	(SWITCH_USTRING): Remove.
	(SWITCH_DSTRING): Remove.
	(SWITCH_ERROR): Remove.
	* toir.cc (IRVisitor::visit): Update for new front-end interface.
	(IRVisitor::check_previous_goto): Remove checks for case and default
	statements.
	(IRVisitor::visit(SwitchStatement *)): Remove handling of string
	switch conditions.
	* typeinfo.cc: Include d-frontend.h.
	(get_typeinfo_kind): Update for new front-end interface.
	(make_frontend_typeinfo): Likewise.
	(TypeInfoVisitor::visit): Likewise.
	(builtin_typeinfo_p): Likewise.
	(get_typeinfo_decl): Likewise.
	(build_typeinfo): Likewise.
	* types.cc (valist_array_p): Likewise.
	(make_array_type): Likewise.
	(merge_aggregate_types): Likewise.
	(TypeVisitor::visit(TypeBasic *)): Likewise.
	(TypeVisitor::visit(TypeFunction *)): Likewise.
	(TypeVisitor::visit(TypeStruct *)): Update comment.
	* verstr.h: Removed.
	* d-frontend.h: New file.

gcc/po/ChangeLog:

	* EXCLUDES: Remove d/dmd sources from list.

gcc/testsuite/ChangeLog:

	* gdc.dg/Wcastresult2.d: Update test.
	* gdc.dg/asm1.d: Likewise.
	* gdc.dg/asm2.d: Likewise.
	* gdc.dg/asm3.d: Likewise.
	* gdc.dg/gdc282.d: Likewise.
	* gdc.dg/imports/gdc170.d: Likewise.
	* gdc.dg/intrinsics.d: Likewise.
	* gdc.dg/pr101672.d: Likewise.
	* gdc.dg/pr90650a.d: Likewise.
	* gdc.dg/pr90650b.d: Likewise.
	* gdc.dg/pr94777a.d: Likewise.
	* gdc.dg/pr95250.d: Likewise.
	* gdc.dg/pr96869.d: Likewise.
	* gdc.dg/pr98277.d: Likewise.
	* gdc.dg/pr98457.d: Likewise.
	* gdc.dg/simd1.d: Likewise.
	* gdc.dg/simd2a.d: Likewise.
	* gdc.dg/simd2b.d: Likewise.
	* gdc.dg/simd2c.d: Likewise.
	* gdc.dg/simd2d.d: Likewise.
	* gdc.dg/simd2e.d: Likewise.
	* gdc.dg/simd2f.d: Likewise.
	* gdc.dg/simd2g.d: Likewise.
	* gdc.dg/simd2h.d: Likewise.
	* gdc.dg/simd2i.d: Likewise.
	* gdc.dg/simd2j.d: Likewise.
	* gdc.dg/simd7951.d: Likewise.
	* gdc.dg/torture/gdc309.d: Likewise.
	* gdc.dg/torture/pr94424.d: Likewise.
	* gdc.dg/torture/pr94777b.d: Likewise.
	* lib/gdc-utils.exp (gdc-convert-args): Handle new compiler options.
	(gdc-convert-test): Handle CXXFLAGS, EXTRA_OBJC_SOURCES, and ARG_SETS
	test directives.
	(gdc-do-test): Only import modules in the test run directory.
	* gdc.dg/pr94777c.d: New test.
	* gdc.dg/pr96156b.d: New test.
	* gdc.dg/pr96157c.d: New test.
	* gdc.dg/simd_ctfe.d: New test.
	* gdc.dg/torture/simd17344.d: New test.
	* gdc.dg/torture/simd20052.d: New test.
	* gdc.dg/torture/simd6.d: New test.
	* gdc.dg/torture/simd7.d: New test.

libphobos/ChangeLog:

	* libdruntime/MERGE: Merge upstream druntime e6caaab9.
	* libdruntime/Makefile.am (D_EXTRA_FLAGS): Build libdruntime with
	-fpreview=dip1000, -fpreview=fieldwise, and -fpreview=dtorfields.
	(ALL_DRUNTIME_SOURCES): Add DRUNTIME_DSOURCES_STDCXX.
	(DRUNTIME_DSOURCES): Update list of C binding modules.
	(DRUNTIME_DSOURCES_STDCXX): Likewise.
	(DRUNTIME_DSOURCES_LINUX): Likewise.
	(DRUNTIME_DSOURCES_OPENBSD): Likewise.
	(DRUNTIME_DISOURCES): Remove __entrypoint.di.
	* libdruntime/Makefile.in: Regenerated.
	* libdruntime/__entrypoint.di: Removed.
	* libdruntime/gcc/deh.d (_d_isbaseof): Update signature.
	(_d_createTrace): Likewise.
	(__gdc_begin_catch): Remove reference to the exception.
	(_d_throw): Increment reference count of thrown object before unwind.
	(__gdc_personality): Chain exceptions with  Throwable.chainTogether.
	* libdruntime/gcc/emutls.d: Update imports.
	* libdruntime/gcc/sections/elf.d: Update imports.
	(DSO.moduleGroup): Update signature.
	* libdruntime/gcc/sections/macho.d: Update imports.
	(DSO.moduleGroup): Update signature.
	* libdruntime/gcc/sections/pecoff.d: Update imports.
	(DSO.moduleGroup): Update signature.
	* src/MERGE: Merge upstream phobos 5ab9ad256.
	* src/Makefile.am (D_EXTRA_DFLAGS): Add -fpreview=dip1000 and
	-fpreview=dtorfields flags.
	(PHOBOS_DSOURCES): Update list of std modules.
	* src/Makefile.in: Regenerate.
	* testsuite/lib/libphobos.exp (libphobos-dg-test): Handle assembly
	compile types.
	(dg-test): Override.
	(additional_prunes): Define.
	(libphobos-dg-prune): Filter any additional_prunes set by tests.
	* testsuite/libphobos.aa/test_aa.d: Update test.
	* testsuite/libphobos.druntime/druntime.exp (version_flags): Add
	-fversion=CoreUnittest.
	* testsuite/libphobos.druntime_shared/druntime_shared.exp
	(version_flags): Add -fversion=CoreUnittest -fversion=Shared.
	* testsuite/libphobos.exceptions/unknown_gc.d: Update test.
	* testsuite/libphobos.hash/test_hash.d: Update test.
	* testsuite/libphobos.phobos/phobos.exp (version_flags): Add
	-fversion=StdUnittest
	* testsuite/libphobos.phobos_shared/phobos_shared.exp (version_flags):
	Likewise.
	* testsuite/libphobos.shared/host.c: Update test.
	* testsuite/libphobos.shared/load.d: Update test.
	* testsuite/libphobos.shared/load_13414.d: Update test.
	* testsuite/libphobos.thread/fiber_guard_page.d: Update test.
	* testsuite/libphobos.thread/tlsgc_sections.d: Update test.
	* testsuite/testsuite_flags.in: Add -fpreview=dip1000 to --gdcflags.
	* testsuite/libphobos.shared/link_mod_collision.d: Removed.
	* testsuite/libphobos.shared/load_mod_collision.d: Removed.
	* testsuite/libphobos.betterc/betterc.exp: New test.
	* testsuite/libphobos.config/config.exp: New test.
	* testsuite/libphobos.gc/gc.exp: New test.
	* testsuite/libphobos.imports/imports.exp: New test.
	* testsuite/libphobos.lifetime/lifetime.exp: New test.
	* testsuite/libphobos.unittest/unittest.exp: New test.

1 files changed, 564 insertions, 0 deletions

diff --git a/libphobos/testsuite/libphobos.exceptions/assert_fail.d b/libphobos/testsuite/libphobos.exceptions/assert_fail.d
new file mode 100644
index 0000000..79b3cb8
--- /dev/null
+++ b/libphobos/testsuite/libphobos.exceptions/assert_fail.d
@@ -0,0 +1,564 @@
+import core.stdc.stdio : fprintf, stderr;
+import core.internal.dassert : _d_assert_fail;
+
+void test(string comp = "==", A, B)(A a, B b, string msg, size_t line = __LINE__)
+{
+    test(_d_assert_fail!(A)(comp, a, b), msg, line);
+}
+
+void test(const string actual, const string expected, size_t line = __LINE__)
+{
+    import core.exception : AssertError;
+
+    if (actual != expected)
+    {
+        const msg = "Mismatch!\nExpected: <" ~ expected ~ ">\nActual:   <" ~ actual ~ '>';
+        throw new AssertError(msg, __FILE__, line);
+    }
+}
+
+void testIntegers()
+{
+    test(1, 2, "1 != 2");
+    test(-10, 8, "-10 != 8");
+    test(byte.min, byte.max, "-128 != 127");
+    test(ubyte.min, ubyte.max, "0 != 255");
+    test(short.min, short.max, "-32768 != 32767");
+    test(ushort.min, ushort.max, "0 != 65535");
+    test(int.min, int.max, "-2147483648 != 2147483647");
+    test(uint.min, uint.max, "0 != 4294967295");
+    test(long.min, long.max, "-9223372036854775808 != 9223372036854775807");
+    test(ulong.min, ulong.max, "0 != 18446744073709551615");
+    test(shared(ulong).min, shared(ulong).max, "0 != 18446744073709551615");
+
+    int testFun() { return 1; }
+    test(testFun(), 2, "1 != 2");
+}
+
+void testIntegerComparisons()
+{
+    test!"!="(2, 2, "2 == 2");
+    test!"<"(2, 1, "2 >= 1");
+    test!"<="(2, 1, "2 > 1");
+    test!">"(1, 2, "1 <= 2");
+    test!">="(1, 2, "1 < 2");
+}
+
+void testFloatingPoint()
+{
+    if (__ctfe)
+    {
+        test(float.max, -float.max, "<float not supported> != <float not supported>");
+        test(double.max, -double.max, "<double not supported> != <double not supported>");
+        test(real(1), real(-1), "<real not supported> != <real not supported>");
+    }
+    else
+    {
+        test(1.5, 2.5, "1.5 != 2.5");
+        test(float.max, -float.max, "3.40282e+38 != -3.40282e+38");
+        test(double.max, -double.max, "1.79769e+308 != -1.79769e+308");
+        test(real(1), real(-1), "1 != -1");
+    }
+}
+
+void testPointers()
+{
+    static struct S
+    {
+        string toString() const { return "S(...)"; }
+    }
+
+    static if ((void*).sizeof == 4)
+        enum ptr = "0x12345670";
+    else
+        enum ptr = "0x123456789abcdef0";
+
+    int* p = cast(int*) mixin(ptr);
+    test(cast(S*) p, p, ptr ~ " != " ~ ptr);
+}
+
+void testStrings()
+{
+    test("foo", "bar", `"foo" != "bar"`);
+    test("", "bar", `"" != "bar"`);
+
+    char[] dlang = "dlang".dup;
+    const(char)[] rust = "rust";
+    test(dlang, rust, `"dlang" != "rust"`);
+
+    // https://issues.dlang.org/show_bug.cgi?id=20322
+    test("left"w, "right"w, `"left" != "right"`);
+    test("left"d, "right"d, `"left" != "right"`);
+
+    test('A', 'B', "'A' != 'B'");
+    test(wchar('❤'), wchar('∑'), "'❤' != '∑'");
+    test(dchar('❤'), dchar('∑'), "'❤' != '∑'");
+
+    // Detect invalid code points
+    test(char(255), 'B', "cast(char) 255 != 'B'");
+    test(wchar(0xD888), wchar('∑'), "cast(wchar) 55432 != '∑'");
+    test(dchar(0xDDDD), dchar('∑'), "cast(dchar) 56797 != '∑'");
+}
+
+void testToString()
+{
+    class Foo
+    {
+        this(string payload) {
+            this.payload = payload;
+        }
+
+        string payload;
+        override string toString() {
+            return "Foo(" ~ payload ~ ")";
+        }
+    }
+    test(new Foo("a"), new Foo("b"), "Foo(a) != Foo(b)");
+
+    scope f = cast(shared) new Foo("a");
+    if (!__ctfe) // Ref somehow get's lost in CTFE
+    test!"!="(f, f, "Foo(a) == Foo(a)");
+
+    // Verifiy that the const toString is selected if present
+    static struct Overloaded
+    {
+        string toString()
+        {
+            return "Mutable";
+        }
+
+        string toString() const
+        {
+            return "Const";
+        }
+    }
+
+    test!"!="(Overloaded(), Overloaded(), "Const == Const");
+
+    Foo fnull = null;
+    test!"!is"(fnull, fnull, "`null` is `null`");
+}
+
+
+void testArray()
+{
+    test([1], [0], "[1] != [0]");
+    test([1, 2, 3], [0], "[1, 2, 3] != [0]");
+
+    // test with long arrays
+    int[] arr;
+    foreach (i; 0 .. 100)
+        arr ~= i;
+    test(arr, [0], "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, ...] != [0]");
+
+    // Ignore fake arrays
+    static struct S
+    {
+        int[2] arr;
+        int[] get() return { return arr[]; }
+        alias get this;
+    }
+
+    const a = S([1, 2]);
+    test(a, S([3, 4]), "S([1, 2]) != S([3, 4])");
+}
+
+void testStruct()
+{
+    struct S { int s; }
+    struct T { T[] t; }
+    test(S(0), S(1), "S(0) != S(1)");
+    test(T([T(null)]), T(null), "T([T([])]) != T([])");
+
+    // https://issues.dlang.org/show_bug.cgi?id=20323
+    static struct NoCopy
+    {
+        @disable this(this);
+    }
+
+    NoCopy n;
+    test(_d_assert_fail!(typeof(n))("!=", n, n), "NoCopy() == NoCopy()");
+
+    shared NoCopy sn;
+    test(_d_assert_fail!(typeof(sn))("!=", sn, sn), "NoCopy() == NoCopy()");
+}
+
+void testAA()
+{
+    test([1:"one"], [2: "two"], `[1: "one"] != [2: "two"]`);
+    test!"in"(1, [2: 3], "1 !in [2: 3]");
+    test!"in"("foo", ["bar": true], `"foo" !in ["bar": true]`);
+}
+
+void testAttributes() @safe pure @nogc nothrow
+{
+    int a;
+    string s = _d_assert_fail!(int, char)("==", a, 'c', 1, 'd');
+    assert(s == `(0, 'c') != (1, 'd')`);
+
+    string s2 = _d_assert_fail!int("", a);
+    assert(s2 == `0 != true`);
+}
+
+// https://issues.dlang.org/show_bug.cgi?id=20066
+void testVoidArray()
+{
+    test!"!is"([], null, (__ctfe ? "<void[] not supported>" : "[]") ~ " is `null`");
+    test!"!is"(null, null, "`null` is `null`");
+    test([1], null, "[1] != `null`");
+    test("s", null, "\"s\" != `null`");
+    test(['c'], null, "\"c\" != `null`");
+    test!"!="(null, null, "`null` == `null`");
+
+    const void[] chunk = [byte(1), byte(2), byte(3)];
+    test(chunk, null, (__ctfe ? "<void[] not supported>" : "[1, 2, 3]") ~ " != `null`");
+}
+
+void testTemporary()
+{
+    static struct Bad
+    {
+        ~this() @system {}
+    }
+
+    test!"!="(Bad(), Bad(), "Bad() == Bad()");
+}
+
+void testEnum()
+{
+    static struct UUID {
+        union
+        {
+            ubyte[] data = [1];
+        }
+    }
+
+    ubyte[] data;
+    enum ctfe = UUID();
+    test(_d_assert_fail!(ubyte[])("==", ctfe.data, data), "[1] != []");
+}
+
+void testUnary()
+{
+    test(_d_assert_fail!int("", 9), "9 != true");
+    test(_d_assert_fail!(int[])("!", [1, 2, 3]), "[1, 2, 3] == true");
+}
+
+void testTuple()
+{
+    test(_d_assert_fail("=="), "() != ()");
+    test(_d_assert_fail("!="), "() == ()");
+    test(_d_assert_fail(">="), "() < ()");
+}
+
+void testStructEquals()
+{
+    struct T {
+        bool b;
+        int i;
+        float f1 = 2.5;
+        float f2 = 0;
+        string s1 = "bar";
+        string s2;
+    }
+
+    T t1;
+    test!"!="(t1, t1, `T(false, 0, 2.5, 0, "bar", "") == T(false, 0, 2.5, 0, "bar", "")`);
+    T t2 = {s1: "bari"};
+    test(t1, t2, `T(false, 0, 2.5, 0, "bar", "") != T(false, 0, 2.5, 0, "bari", "")`);
+}
+
+void testStructEquals2()
+{
+    struct T {
+        bool b;
+        int i;
+        float f1 = 2.5;
+        float f2 = 0;
+    }
+
+    T t1;
+    test!"!="(t1, t1, `T(false, 0, 2.5, 0) == T(false, 0, 2.5, 0)`);
+    T t2 = {i: 2};
+    test(t1, t2, `T(false, 0, 2.5, 0) != T(false, 2, 2.5, 0)`);
+}
+
+void testStructEquals3()
+{
+    struct T {
+        bool b;
+        int i;
+        string s1 = "bar";
+        string s2;
+    }
+
+    T t1;
+    test!"!="(t1, t1, `T(false, 0, "bar", "") == T(false, 0, "bar", "")`);
+    T t2 = {s1: "bari"};
+    test(t1, t2, `T(false, 0, "bar", "") != T(false, 0, "bari", "")`);
+}
+
+void testStructEquals4()
+{
+    struct T {
+        float f1 = 2.5;
+        float f2 = 0;
+        string s1 = "bar";
+        string s2;
+    }
+
+    T t1;
+    test!"!="(t1, t1, `T(2.5, 0, "bar", "") == T(2.5, 0, "bar", "")`);
+    T t2 = {s1: "bari"};
+    test(t1, t2, `T(2.5, 0, "bar", "") != T(2.5, 0, "bari", "")`);
+}
+
+void testStructEquals5()
+{
+    struct T {
+        bool b;
+        int i;
+        float f2 = 0;
+        string s2;
+    }
+
+    T t1;
+    test!"!="(t1, t1, `T(false, 0, 0, "") == T(false, 0, 0, "")`);
+    T t2 = {b: true};
+    test(t1, t2, `T(false, 0, 0, "") != T(true, 0, 0, "")`);
+}
+
+void testStructEquals6()
+{
+    class C { override string toString() { return "C()"; }}
+    struct T {
+        bool b;
+        int i;
+        float f2 = 0;
+        string s2;
+        int[] arr;
+        C c;
+    }
+
+    T t1;
+    test!"!="(t1, t1, "T(false, 0, 0, \"\", [], `null`) == T(false, 0, 0, \"\", [], `null`)");
+    T t2 = {arr: [1]};
+    test(t1, t2, "T(false, 0, 0, \"\", [], `null`) != T(false, 0, 0, \"\", [1], `null`)");
+    T t3 = {c: new C()};
+    test(t1, t3, "T(false, 0, 0, \"\", [], `null`) != T(false, 0, 0, \"\", [], C())");
+}
+
+void testContextPointer()
+{
+    int i;
+    struct T
+    {
+        int j;
+        int get()
+        {
+            return i * j;
+        }
+    }
+    T t = T(1);
+    t.tupleof[$-1] = cast(void*) 0xABCD; // Deterministic context pointer
+    test(t, t, `T(1, <context>: 0xabcd) != T(1, <context>: 0xabcd)`);
+}
+
+void testExternClasses()
+{
+    {
+        extern(C++) static class Cpp
+        {
+            int a;
+            this(int a) { this.a = a; }
+        }
+        scope a = new Cpp(1);
+        scope b = new Cpp(2);
+        test(a, b, "Cpp(1) != Cpp(2)");
+        test(a, Cpp.init, "Cpp(1) != null");
+    }
+    {
+        extern(C++) static class CppToString
+        {
+            int a;
+            this(int a) { this.a = a; }
+            extern(D) string toString() const { return a == 0 ? "hello" : "world"; }
+        }
+        scope a = new CppToString(0);
+        scope b = new CppToString(1);
+        test(a, b, "hello != world");
+    }
+    if (!__ctfe)
+    {
+        extern(C++) static class Opaque;
+        Opaque null_ = null;
+        Opaque notNull = cast(Opaque) &null_;
+        test(null_, notNull, "null != <Opaque>");
+    }
+    {
+        extern(C++) static interface Stuff {}
+        scope Stuff stuff = new class Stuff {};
+        test(stuff, Stuff.init, "Stuff() != null");
+    }
+}
+
+void testShared()
+{
+    static struct Small
+    {
+        int i;
+    }
+
+    auto s1 = shared Small(1);
+    const s2 = shared Small(2);
+    test(s1, s2, "Small(1) != Small(2)");
+
+    static struct Big
+    {
+        long[10] l;
+    }
+
+    auto b1 = shared Big([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    const b2 = shared Big();
+    test(b1, b2, "Big([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) != Big([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])");
+
+    // Sanity check: Big shouldn't be supported by atomicLoad
+    import core.atomic : atomicLoad;
+    static assert( __traits(compiles, atomicLoad(s1)));
+    static assert(!__traits(compiles, atomicLoad(b1)));
+}
+
+void testException()
+{
+    static struct MayThrow
+    {
+        int i;
+        string toString()
+        {
+            if (i == 1)
+                throw new Exception("Error");
+            return "Some message";
+        }
+    }
+
+    test(MayThrow(0), MayThrow(1), `Some message != <toString() failed: "Error", called on MayThrow(1)>`);
+}
+
+void testOverlappingFields()
+{
+    static struct S
+    {
+        union
+        {
+            double num;
+            immutable(char)[] name;
+        }
+    }
+
+    test(S(1.0), S(2.0), "S(<overlapped field>, <overlapped field>) != S(<overlapped field>, <overlapped field>)");
+
+    static struct S2
+    {
+        int valid;
+        union
+        {
+            double num;
+            immutable(char)[] name;
+        }
+    }
+
+    test(S2(4, 1.0), S2(5, 2.0), "S2(4, <overlapped field>, <overlapped field>) != S2(5, <overlapped field>, <overlapped field>)");
+
+    static struct S3
+    {
+        union
+        {
+            double num;
+            immutable(char)[] name;
+        }
+        int valid;
+    }
+    S3 a = {
+        num: 1.0,
+        valid: 8
+    };
+
+    S3 b = {
+        num: 1.0,
+        valid: 8
+    };
+    test(a, b, "S3(<overlapped field>, <overlapped field>, 8) != S3(<overlapped field>, <overlapped field>, 8)");
+}
+
+void testDestruction()
+{
+    static class Test
+    {
+        __gshared string unary, binary;
+        __gshared bool run;
+
+        ~this()
+        {
+            run = true;
+            unary = _d_assert_fail!int("", 1);
+            binary = _d_assert_fail!int("==", 1, 2);
+        }
+    }
+
+    static void createGarbage()
+    {
+        new Test();
+        new long[100];
+    }
+
+    import core.memory : GC;
+    createGarbage();
+    GC.collect();
+
+    assert(Test.run);
+    assert(Test.unary == "Assertion failed (rich formatting is disabled in finalizers)");
+    assert(Test.binary == "Assertion failed (rich formatting is disabled in finalizers)");
+}
+
+int main()
+{
+    testIntegers();
+    testIntegerComparisons();
+    testFloatingPoint();
+    testPointers();
+    testStrings();
+    testToString();
+    testArray();
+    testStruct();
+    testAA();
+    testAttributes();
+    testVoidArray();
+    testTemporary();
+    testEnum();
+    testUnary();
+    testTuple();
+    if (!__ctfe)
+        testStructEquals();
+    if (!__ctfe)
+        testStructEquals2();
+    testStructEquals3();
+    if (!__ctfe)
+        testStructEquals4();
+    if (!__ctfe)
+        testStructEquals5();
+    if (!__ctfe)
+        testStructEquals6();
+    testContextPointer();
+    testExternClasses();
+    testShared();
+    testException();
+    testOverlappingFields();
+    if (!__ctfe)
+        testDestruction();
+
+    if (!__ctfe)
+        fprintf(stderr, "success.\n");
+    return 0;
+}
+
+enum forceCTFE = main();