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, 0 insertions, 634 deletions

diff --git a/gcc/d/dmd/arrayop.c b/gcc/d/dmd/arrayop.c
deleted file mode 100644
index 52d596b..0000000
--- a/gcc/d/dmd/arrayop.c
+++ /dev/null
@@ -1,634 +0,0 @@
-
-/* Compiler implementation of the D programming language
- * Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
- * written by Walter Bright
- * http://www.digitalmars.com
- * Distributed under the Boost Software License, Version 1.0.
- * http://www.boost.org/LICENSE_1_0.txt
- * https://github.com/D-Programming-Language/dmd/blob/master/src/arrayop.c
- */
-
-#include "root/dsystem.h"
-#include "root/rmem.h"
-#include "root/aav.h"
-
-#include "mars.h"
-#include "expression.h"
-#include "statement.h"
-#include "mtype.h"
-#include "declaration.h"
-#include "scope.h"
-#include "id.h"
-#include "module.h"
-#include "init.h"
-#include "tokens.h"
-
-void buildArrayIdent(Expression *e, OutBuffer *buf, Expressions *arguments);
-Expression *buildArrayLoop(Expression *e, Parameters *fparams);
-
-/**************************************
- * Hash table of array op functions already generated or known about.
- */
-
-AA *arrayfuncs;
-
-/**************************************
- * Structure to contain information needed to insert an array op call
- */
-
-FuncDeclaration *buildArrayOp(Identifier *ident, BinExp *exp, Scope *sc)
-{
-    Parameters *fparams = new Parameters();
-    Expression *loopbody = buildArrayLoop(exp, fparams);
-
-    /* Construct the function body:
-     *  foreach (i; 0 .. p.length)    for (size_t i = 0; i < p.length; i++)
-     *      loopbody;
-     *  return p;
-     */
-
-    Parameter *p = (*fparams)[0];
-    // foreach (i; 0 .. p.length)
-    Statement *s1 = new ForeachRangeStatement(Loc(), TOKforeach,
-        new Parameter(0, NULL, Id::p, NULL, NULL),
-        new IntegerExp(Loc(), 0, Type::tsize_t),
-        new ArrayLengthExp(Loc(), new IdentifierExp(Loc(), p->ident)),
-        new ExpStatement(Loc(), loopbody),
-        Loc());
-    //printf("%s\n", s1->toChars());
-    Statement *s2 = new ReturnStatement(Loc(), new IdentifierExp(Loc(), p->ident));
-    //printf("s2: %s\n", s2->toChars());
-    Statement *fbody = new CompoundStatement(Loc(), s1, s2);
-
-    // Built-in array ops should be @trusted, pure, nothrow and nogc
-    StorageClass stc = STCtrusted | STCpure | STCnothrow | STCnogc;
-
-    /* Construct the function
-     */
-    TypeFunction *ftype = new TypeFunction(ParameterList(fparams), exp->e1->type, LINKc, stc);
-    //printf("fd: %s %s\n", ident->toChars(), ftype->toChars());
-    FuncDeclaration *fd = new FuncDeclaration(Loc(), Loc(), ident, STCundefined, ftype);
-    fd->fbody = fbody;
-    fd->protection = Prot(Prot::public_);
-    fd->linkage = LINKc;
-    fd->isArrayOp = 1;
-
-    sc->_module->importedFrom->members->push(fd);
-
-    sc = sc->push();
-    sc->parent = sc->_module->importedFrom;
-    sc->stc = 0;
-    sc->linkage = LINKc;
-    dsymbolSemantic(fd, sc);
-    semantic2(fd, sc);
-    unsigned errors = global.startGagging();
-    semantic3(fd, sc);
-    if (global.endGagging(errors))
-    {
-        fd->type = Type::terror;
-        fd->errors = true;
-        fd->fbody = NULL;
-    }
-    sc->pop();
-
-    return fd;
-}
-
-/**********************************************
- * Check that there are no uses of arrays without [].
- */
-bool isArrayOpValid(Expression *e)
-{
-    if (e->op == TOKslice)
-        return true;
-    if (e->op == TOKarrayliteral)
-    {
-        Type *t = e->type->toBasetype();
-        while (t->ty == Tarray || t->ty == Tsarray)
-            t = t->nextOf()->toBasetype();
-        return (t->ty != Tvoid);
-    }
-    Type *tb = e->type->toBasetype();
-    if (tb->ty == Tarray || tb->ty == Tsarray)
-    {
-        if (isUnaArrayOp(e->op))
-        {
-             return isArrayOpValid(((UnaExp *)e)->e1);
-        }
-        if (isBinArrayOp(e->op) ||
-            isBinAssignArrayOp(e->op) ||
-            e->op == TOKassign)
-        {
-            BinExp *be = (BinExp *)e;
-            return isArrayOpValid(be->e1) && isArrayOpValid(be->e2);
-        }
-        if (e->op == TOKconstruct)
-        {
-            BinExp *be = (BinExp *)e;
-            return be->e1->op == TOKslice && isArrayOpValid(be->e2);
-        }
-        if (e->op == TOKcall)
-        {
-             return false; // TODO: Decide if [] is required after arrayop calls.
-        }
-        else
-        {
-            return false;
-        }
-    }
-    return true;
-}
-
-bool isNonAssignmentArrayOp(Expression *e)
-{
-    if (e->op == TOKslice)
-        return isNonAssignmentArrayOp(((SliceExp *)e)->e1);
-
-    Type *tb = e->type->toBasetype();
-    if (tb->ty == Tarray || tb->ty == Tsarray)
-    {
-        return (isUnaArrayOp(e->op) || isBinArrayOp(e->op));
-    }
-    return false;
-}
-
-bool checkNonAssignmentArrayOp(Expression *e, bool suggestion)
-{
-    if (isNonAssignmentArrayOp(e))
-    {
-        const char *s = "";
-        if (suggestion)
-            s = " (possible missing [])";
-        e->error("array operation %s without destination memory not allowed%s", e->toChars(), s);
-        return true;
-    }
-    return false;
-}
-
-/***********************************
- * Construct the array operation expression.
- */
-
-Expression *arrayOp(BinExp *e, Scope *sc)
-{
-    //printf("BinExp::arrayOp() %s\n", toChars());
-
-    Type *tb = e->type->toBasetype();
-    assert(tb->ty == Tarray || tb->ty == Tsarray);
-    Type *tbn = tb->nextOf()->toBasetype();
-    if (tbn->ty == Tvoid)
-    {
-        e->error("cannot perform array operations on void[] arrays");
-        return new ErrorExp();
-    }
-    if (!isArrayOpValid(e))
-    {
-        e->error("invalid array operation %s (possible missing [])", e->toChars());
-        return new ErrorExp();
-    }
-
-    Expressions *arguments = new Expressions();
-
-    /* The expression to generate an array operation for is mangled
-     * into a name to use as the array operation function name.
-     * Mangle in the operands and operators in RPN order, and type.
-     */
-    OutBuffer buf;
-    buf.writestring("_array");
-    buildArrayIdent(e, &buf, arguments);
-    buf.writeByte('_');
-
-    /* Append deco of array element type
-     */
-    buf.writestring(e->type->toBasetype()->nextOf()->toBasetype()->mutableOf()->deco);
-
-    char *name = buf.peekChars();
-    Identifier *ident = Identifier::idPool(name);
-
-    FuncDeclaration **pFd = (FuncDeclaration **)dmd_aaGet(&arrayfuncs, (void *)ident);
-    FuncDeclaration *fd = *pFd;
-
-    if (!fd)
-        fd = buildArrayOp(ident, e, sc);
-
-    if (fd && fd->errors)
-    {
-        const char *fmt;
-        if (tbn->ty == Tstruct || tbn->ty == Tclass)
-            fmt = "invalid array operation '%s' because %s doesn't support necessary arithmetic operations";
-        else if (!tbn->isscalar())
-            fmt = "invalid array operation '%s' because %s is not a scalar type";
-        else
-            fmt = "invalid array operation '%s' for element type %s";
-
-        e->error(fmt, e->toChars(), tbn->toChars());
-        return new ErrorExp();
-    }
-
-    *pFd = fd;
-
-    Expression *ev = new VarExp(e->loc, fd);
-    Expression *ec = new CallExp(e->loc, ev, arguments);
-
-    return expressionSemantic(ec, sc);
-}
-
-Expression *arrayOp(BinAssignExp *e, Scope *sc)
-{
-    //printf("BinAssignExp::arrayOp() %s\n", toChars());
-
-    /* Check that the elements of e1 can be assigned to
-     */
-    Type *tn = e->e1->type->toBasetype()->nextOf();
-
-    if (tn && (!tn->isMutable() || !tn->isAssignable()))
-    {
-        e->error("slice %s is not mutable", e->e1->toChars());
-        return new ErrorExp();
-    }
-    if (e->e1->op == TOKarrayliteral)
-    {
-        return e->e1->modifiableLvalue(sc, e->e1);
-    }
-
-    return arrayOp((BinExp *)e, sc);
-}
-
-/******************************************
- * Construct the identifier for the array operation function,
- * and build the argument list to pass to it.
- */
-
-void buildArrayIdent(Expression *e, OutBuffer *buf, Expressions *arguments)
-{
-    class BuildArrayIdentVisitor : public Visitor
-    {
-        OutBuffer *buf;
-        Expressions *arguments;
-    public:
-        BuildArrayIdentVisitor(OutBuffer *buf, Expressions *arguments)
-            : buf(buf), arguments(arguments)
-        {
-        }
-
-        void visit(Expression *e)
-        {
-            buf->writestring("Exp");
-            arguments->shift(e);
-        }
-
-        void visit(CastExp *e)
-        {
-            Type *tb = e->type->toBasetype();
-            if (tb->ty == Tarray || tb->ty == Tsarray)
-            {
-                e->e1->accept(this);
-            }
-            else
-                visit((Expression *)e);
-        }
-
-        void visit(ArrayLiteralExp *e)
-        {
-            buf->writestring("Slice");
-            arguments->shift(e);
-        }
-
-        void visit(SliceExp *e)
-        {
-            buf->writestring("Slice");
-            arguments->shift(e);
-        }
-
-        void visit(AssignExp *e)
-        {
-            /* Evaluate assign expressions right to left
-             */
-            e->e2->accept(this);
-            e->e1->accept(this);
-            buf->writestring("Assign");
-        }
-
-        void visit(BinAssignExp *e)
-        {
-            /* Evaluate assign expressions right to left
-             */
-            e->e2->accept(this);
-            e->e1->accept(this);
-            const char *s;
-            switch(e->op)
-            {
-            case TOKaddass: s = "Addass"; break;
-            case TOKminass: s = "Minass"; break;
-            case TOKmulass: s = "Mulass"; break;
-            case TOKdivass: s = "Divass"; break;
-            case TOKmodass: s = "Modass"; break;
-            case TOKxorass: s = "Xorass"; break;
-            case TOKandass: s = "Andass"; break;
-            case TOKorass:  s = "Orass";  break;
-            case TOKpowass: s = "Powass"; break;
-            default: assert(0);
-            }
-            buf->writestring(s);
-        }
-
-        void visit(NegExp *e)
-        {
-            e->e1->accept(this);
-            buf->writestring("Neg");
-        }
-
-        void visit(ComExp *e)
-        {
-            e->e1->accept(this);
-            buf->writestring("Com");
-        }
-
-        void visit(BinExp *e)
-        {
-            /* Evaluate assign expressions left to right
-             */
-            const char *s = NULL;
-            switch(e->op)
-            {
-            case TOKadd: s = "Add"; break;
-            case TOKmin: s = "Min"; break;
-            case TOKmul: s = "Mul"; break;
-            case TOKdiv: s = "Div"; break;
-            case TOKmod: s = "Mod"; break;
-            case TOKxor: s = "Xor"; break;
-            case TOKand: s = "And"; break;
-            case TOKor:  s = "Or";  break;
-            case TOKpow: s = "Pow"; break;
-            default: break;
-            }
-            if (s)
-            {
-                Type *tb = e->type->toBasetype();
-                Type *t1 = e->e1->type->toBasetype();
-                Type *t2 = e->e2->type->toBasetype();
-                e->e1->accept(this);
-                if (t1->ty == Tarray &&
-                    ((t2->ty == Tarray && !t1->equivalent(tb)) ||
-                     (t2->ty != Tarray && !t1->nextOf()->equivalent(e->e2->type))))
-                {
-                    // Bugzilla 12780: if A is narrower than B
-                    //  A[] op B[]
-                    //  A[] op B
-                    buf->writestring("Of");
-                    buf->writestring(t1->nextOf()->mutableOf()->deco);
-                }
-                e->e2->accept(this);
-                if (t2->ty == Tarray &&
-                    ((t1->ty == Tarray && !t2->equivalent(tb)) ||
-                     (t1->ty != Tarray && !t2->nextOf()->equivalent(e->e1->type))))
-                {
-                    // Bugzilla 12780: if B is narrower than A:
-                    //  A[] op B[]
-                    //  A op B[]
-                    buf->writestring("Of");
-                    buf->writestring(t2->nextOf()->mutableOf()->deco);
-                }
-                buf->writestring(s);
-            }
-            else
-                visit((Expression *)e);
-        }
-    };
-
-    BuildArrayIdentVisitor v(buf, arguments);
-    e->accept(&v);
-}
-
-/******************************************
- * Construct the inner loop for the array operation function,
- * and build the parameter list.
- */
-
-Expression *buildArrayLoop(Expression *e, Parameters *fparams)
-{
-    class BuildArrayLoopVisitor : public Visitor
-    {
-        Parameters *fparams;
-        Expression *result;
-
-    public:
-        BuildArrayLoopVisitor(Parameters *fparams)
-            : fparams(fparams), result(NULL)
-        {
-        }
-
-        void visit(Expression *e)
-        {
-            Identifier *id = Identifier::generateId("c", fparams->length);
-            Parameter *param = new Parameter(0, e->type, id, NULL, NULL);
-            fparams->shift(param);
-            result = new IdentifierExp(Loc(), id);
-        }
-
-        void visit(CastExp *e)
-        {
-            Type *tb = e->type->toBasetype();
-            if (tb->ty == Tarray || tb->ty == Tsarray)
-            {
-                e->e1->accept(this);
-            }
-            else
-                visit((Expression *)e);
-        }
-
-        void visit(ArrayLiteralExp *e)
-        {
-            Identifier *id = Identifier::generateId("p", fparams->length);
-            Parameter *param = new Parameter(STCconst, e->type, id, NULL, NULL);
-            fparams->shift(param);
-            Expression *ie = new IdentifierExp(Loc(), id);
-            Expression *index = new IdentifierExp(Loc(), Id::p);
-            result = new ArrayExp(Loc(), ie, index);
-        }
-
-        void visit(SliceExp *e)
-        {
-            Identifier *id = Identifier::generateId("p", fparams->length);
-            Parameter *param = new Parameter(STCconst, e->type, id, NULL, NULL);
-            fparams->shift(param);
-            Expression *ie = new IdentifierExp(Loc(), id);
-            Expression *index = new IdentifierExp(Loc(), Id::p);
-            result = new ArrayExp(Loc(), ie, index);
-        }
-
-        void visit(AssignExp *e)
-        {
-            /* Evaluate assign expressions right to left
-             */
-            Expression *ex2 = buildArrayLoop(e->e2);
-            /* Need the cast because:
-             *   b = c + p[i];
-             * where b is a byte fails because (c + p[i]) is an int
-             * which cannot be implicitly cast to byte.
-             */
-            ex2 = new CastExp(Loc(), ex2, e->e1->type->nextOf());
-            Expression *ex1 = buildArrayLoop(e->e1);
-            Parameter *param = (*fparams)[0];
-            param->storageClass = 0;
-            result = new AssignExp(Loc(), ex1, ex2);
-        }
-
-        void visit(BinAssignExp *e)
-        {
-            /* Evaluate assign expressions right to left
-             */
-            Expression *ex2 = buildArrayLoop(e->e2);
-            Expression *ex1 = buildArrayLoop(e->e1);
-            Parameter *param = (*fparams)[0];
-            param->storageClass = 0;
-            switch(e->op)
-            {
-            case TOKaddass: result = new AddAssignExp(e->loc, ex1, ex2); return;
-            case TOKminass: result = new MinAssignExp(e->loc, ex1, ex2); return;
-            case TOKmulass: result = new MulAssignExp(e->loc, ex1, ex2); return;
-            case TOKdivass: result = new DivAssignExp(e->loc, ex1, ex2); return;
-            case TOKmodass: result = new ModAssignExp(e->loc, ex1, ex2); return;
-            case TOKxorass: result = new XorAssignExp(e->loc, ex1, ex2); return;
-            case TOKandass: result = new AndAssignExp(e->loc, ex1, ex2); return;
-            case TOKorass:  result = new OrAssignExp(e->loc, ex1, ex2); return;
-            case TOKpowass: result = new PowAssignExp(e->loc, ex1, ex2); return;
-            default:
-                assert(0);
-            }
-        }
-
-        void visit(NegExp *e)
-        {
-            Expression *ex1 = buildArrayLoop(e->e1);
-            result = new NegExp(Loc(), ex1);
-        }
-
-        void visit(ComExp *e)
-        {
-            Expression *ex1 = buildArrayLoop(e->e1);
-            result = new ComExp(Loc(), ex1);
-        }
-
-        void visit(BinExp *e)
-        {
-            if (isBinArrayOp(e->op))
-            {
-                /* Evaluate assign expressions left to right
-                 */
-                BinExp *be = (BinExp *)e->copy();
-                be->e1 = buildArrayLoop(be->e1);
-                be->e2 = buildArrayLoop(be->e2);
-                be->type = NULL;
-                result = be;
-                return;
-            }
-            else
-            {
-                visit((Expression *)e);
-                return;
-            }
-        }
-
-        Expression *buildArrayLoop(Expression *e)
-        {
-            e->accept(this);
-            return result;
-        }
-    };
-
-    BuildArrayLoopVisitor v(fparams);
-    return v.buildArrayLoop(e);
-}
-
-/***********************************************
- * Test if expression is a unary array op.
- */
-
-bool isUnaArrayOp(TOK op)
-{
-    switch (op)
-    {
-    case TOKneg:
-    case TOKtilde:
-        return true;
-    default:
-        break;
-    }
-    return false;
-}
-
-/***********************************************
- * Test if expression is a binary array op.
- */
-
-bool isBinArrayOp(TOK op)
-{
-    switch (op)
-    {
-    case TOKadd:
-    case TOKmin:
-    case TOKmul:
-    case TOKdiv:
-    case TOKmod:
-    case TOKxor:
-    case TOKand:
-    case TOKor:
-    case TOKpow:
-        return true;
-    default:
-        break;
-    }
-    return false;
-}
-
-/***********************************************
- * Test if expression is a binary assignment array op.
- */
-
-bool isBinAssignArrayOp(TOK op)
-{
-    switch (op)
-    {
-    case TOKaddass:
-    case TOKminass:
-    case TOKmulass:
-    case TOKdivass:
-    case TOKmodass:
-    case TOKxorass:
-    case TOKandass:
-    case TOKorass:
-    case TOKpowass:
-        return true;
-    default:
-        break;
-    }
-    return false;
-}
-
-/***********************************************
- * Test if operand is a valid array op operand.
- */
-
-bool isArrayOpOperand(Expression *e)
-{
-    //printf("Expression::isArrayOpOperand() %s\n", e->toChars());
-    if (e->op == TOKslice)
-        return true;
-    if (e->op == TOKarrayliteral)
-    {
-        Type *t = e->type->toBasetype();
-        while (t->ty == Tarray || t->ty == Tsarray)
-            t = t->nextOf()->toBasetype();
-        return (t->ty != Tvoid);
-    }
-    Type *tb = e->type->toBasetype();
-    if (tb->ty == Tarray)
-    {
-        return (isUnaArrayOp(e->op) ||
-                isBinArrayOp(e->op) ||
-                isBinAssignArrayOp(e->op) ||
-                e->op == TOKassign);
-    }
-    return false;
-}