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

diff --git a/gcc/d/dmd/aggregate.d b/gcc/d/dmd/aggregate.d
new file mode 100644
index 00000000000..cff4b9feb45
--- /dev/null
+++ b/gcc/d/dmd/aggregate.d
@@ -0,0 +1,769 @@
+/**
+ * Defines a `Dsymbol` representing an aggregate, which is a `struct`, `union` or `class`.
+ *
+ * Specification: $(LINK2 https://dlang.org/spec/struct.html, Structs, Unions),
+ *                $(LINK2 https://dlang.org/spec/class.html, Class).
+ *
+ * Copyright:   Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
+ * Authors:     $(LINK2 http://www.digitalmars.com, Walter Bright)
+ * License:     $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/aggregate.d, _aggregate.d)
+ * Documentation:  https://dlang.org/phobos/dmd_aggregate.html
+ * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/aggregate.d
+ */
+
+module dmd.aggregate;
+
+import core.stdc.stdio;
+import core.checkedint;
+
+import dmd.aliasthis;
+import dmd.apply;
+import dmd.arraytypes;
+import dmd.astenums;
+import dmd.declaration;
+import dmd.dscope;
+import dmd.dstruct;
+import dmd.dsymbol;
+import dmd.dsymbolsem;
+import dmd.dtemplate;
+import dmd.errors;
+import dmd.expression;
+import dmd.func;
+import dmd.globals;
+import dmd.id;
+import dmd.identifier;
+import dmd.mtype;
+import dmd.tokens;
+import dmd.typesem : defaultInit;
+import dmd.visitor;
+
+/**
+ * The ClassKind enum is used in AggregateDeclaration AST nodes to
+ * specify the linkage type of the struct/class/interface or if it
+ * is an anonymous class. If the class is anonymous it is also
+ * considered to be a D class.
+ */
+enum ClassKind : ubyte
+{
+    /// the aggregate is a d(efault) class
+    d,
+    /// the aggregate is a C++ struct/class/interface
+    cpp,
+    /// the aggregate is an Objective-C class/interface
+    objc,
+    /// the aggregate is a C struct
+    c,
+}
+
+/**
+ * If an aggregate has a pargma(mangle, ...) this holds the information
+ * to mangle.
+ */
+struct MangleOverride
+{
+    Dsymbol agg;   // The symbol to copy template parameters from (if any)
+    Identifier id; // the name to override the aggregate's with, defaults to agg.ident
+}
+
+/***********************************************************
+ * Abstract aggregate as a common ancestor for Class- and StructDeclaration.
+ */
+extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
+{
+    Type type;                  ///
+    StorageClass storage_class; ///
+    uint structsize;            /// size of struct
+    uint alignsize;             /// size of struct for alignment purposes
+    VarDeclarations fields;     /// VarDeclaration fields
+    Dsymbol deferred;           /// any deferred semantic2() or semantic3() symbol
+
+    /// specifies whether this is a D, C++, Objective-C or anonymous struct/class/interface
+    ClassKind classKind;
+    /// Specify whether to mangle the aggregate as a `class` or a `struct`
+    /// This information is used by the MSVC mangler
+    /// Only valid for class and struct. TODO: Merge with ClassKind ?
+    CPPMANGLE cppmangle;
+
+    /// overridden symbol with pragma(mangle, "...") if not null
+    MangleOverride* mangleOverride;
+
+    /**
+     * !=null if is nested
+     * pointing to the dsymbol that directly enclosing it.
+     * 1. The function that enclosing it (nested struct and class)
+     * 2. The class that enclosing it (nested class only)
+     * 3. If enclosing aggregate is template, its enclosing dsymbol.
+     *
+     * See AggregateDeclaraton::makeNested for the details.
+     */
+    Dsymbol enclosing;
+
+    VarDeclaration vthis;   /// 'this' parameter if this aggregate is nested
+    VarDeclaration vthis2;  /// 'this' parameter if this aggregate is a template and is nested
+
+    // Special member functions
+    FuncDeclarations invs;  /// Array of invariants
+    FuncDeclaration inv;    /// Merged invariant calling all members of invs
+
+    /// CtorDeclaration or TemplateDeclaration
+    Dsymbol ctor;
+
+    /// default constructor - should have no arguments, because
+    /// it would be stored in TypeInfo_Class.defaultConstructor
+    CtorDeclaration defaultCtor;
+
+    AliasThis aliasthis;    /// forward unresolved lookups to aliasthis
+
+    DtorDeclarations dtors;     /// Array of destructors
+    DtorDeclaration dtor;       /// aggregate destructor calling dtors and member constructors
+    DtorDeclaration primaryDtor;/// non-deleting C++ destructor, same as dtor for D
+    DtorDeclaration tidtor;     /// aggregate destructor used in TypeInfo (must have extern(D) ABI)
+    FuncDeclaration fieldDtor;  /// aggregate destructor for just the fields
+
+    Expression getRTInfo;   /// pointer to GC info generated by object.RTInfo(this)
+
+    ///
+    Visibility visibility;
+    bool noDefaultCtor;             /// no default construction
+    bool disableNew;                /// disallow allocations using `new`
+    Sizeok sizeok = Sizeok.none;    /// set when structsize contains valid data
+
+    final extern (D) this(const ref Loc loc, Identifier id)
+    {
+        super(loc, id);
+        visibility = Visibility(Visibility.Kind.public_);
+    }
+
+    /***************************************
+     * Create a new scope from sc.
+     * semantic, semantic2 and semantic3 will use this for aggregate members.
+     */
+    Scope* newScope(Scope* sc)
+    {
+        auto sc2 = sc.push(this);
+        sc2.stc &= STC.flowThruAggregate;
+        sc2.parent = this;
+        sc2.inunion = isUnionDeclaration();
+        sc2.visibility = Visibility(Visibility.Kind.public_);
+        sc2.explicitVisibility = 0;
+        sc2.aligndecl = null;
+        sc2.userAttribDecl = null;
+        sc2.namespace = null;
+        return sc2;
+    }
+
+    override final void setScope(Scope* sc)
+    {
+        // Might need a scope to resolve forward references. The check for
+        // semanticRun prevents unnecessary setting of _scope during deferred
+        // setScope phases for aggregates which already finished semantic().
+        // See https://issues.dlang.org/show_bug.cgi?id=16607
+        if (semanticRun < PASS.semanticdone)
+            ScopeDsymbol.setScope(sc);
+    }
+
+    /***************************************
+     * Returns:
+     *      The total number of fields minus the number of hidden fields.
+     */
+    final size_t nonHiddenFields()
+    {
+        return fields.dim - isNested() - (vthis2 !is null);
+    }
+
+    /***************************************
+     * Collect all instance fields, then determine instance size.
+     * Returns:
+     *      false if failed to determine the size.
+     */
+    final bool determineSize(Loc loc)
+    {
+        //printf("AggregateDeclaration::determineSize() %s, sizeok = %d\n", toChars(), sizeok);
+
+        // The previous instance size finalizing had:
+        if (type.ty == Terror)
+            return false;   // failed already
+        if (sizeok == Sizeok.done)
+            return true;    // succeeded
+
+        if (!members)
+        {
+            error(loc, "unknown size");
+            return false;
+        }
+
+        if (_scope)
+            dsymbolSemantic(this, null);
+
+        // Determine the instance size of base class first.
+        if (auto cd = isClassDeclaration())
+        {
+            cd = cd.baseClass;
+            if (cd && !cd.determineSize(loc))
+                goto Lfail;
+        }
+
+        // Determine instance fields when sizeok == Sizeok.none
+        if (!this.determineFields())
+            goto Lfail;
+        if (sizeok != Sizeok.done)
+            finalizeSize();
+
+        // this aggregate type has:
+        if (type.ty == Terror)
+            return false;   // marked as invalid during the finalizing.
+        if (sizeok == Sizeok.done)
+            return true;    // succeeded to calculate instance size.
+
+    Lfail:
+        // There's unresolvable forward reference.
+        if (type != Type.terror)
+            error(loc, "no size because of forward reference");
+        // Don't cache errors from speculative semantic, might be resolvable later.
+        // https://issues.dlang.org/show_bug.cgi?id=16574
+        if (!global.gag)
+        {
+            type = Type.terror;
+            errors = true;
+        }
+        return false;
+    }
+
+    abstract void finalizeSize();
+
+    override final d_uns64 size(const ref Loc loc)
+    {
+        //printf("+AggregateDeclaration::size() %s, scope = %p, sizeok = %d\n", toChars(), _scope, sizeok);
+        bool ok = determineSize(loc);
+        //printf("-AggregateDeclaration::size() %s, scope = %p, sizeok = %d\n", toChars(), _scope, sizeok);
+        return ok ? structsize : SIZE_INVALID;
+    }
+
+    /***************************************
+     * Calculate field[i].overlapped and overlapUnsafe, and check that all of explicit
+     * field initializers have unique memory space on instance.
+     * Returns:
+     *      true if any errors happen.
+     */
+    extern (D) final bool checkOverlappedFields()
+    {
+        //printf("AggregateDeclaration::checkOverlappedFields() %s\n", toChars());
+        assert(sizeok == Sizeok.done);
+        size_t nfields = fields.dim;
+        if (isNested())
+        {
+            auto cd = isClassDeclaration();
+            if (!cd || !cd.baseClass || !cd.baseClass.isNested())
+                nfields--;
+            if (vthis2 && !(cd && cd.baseClass && cd.baseClass.vthis2))
+                nfields--;
+        }
+        bool errors = false;
+
+        // Fill in missing any elements with default initializers
+        foreach (i; 0 .. nfields)
+        {
+            auto vd = fields[i];
+            if (vd.errors)
+            {
+                errors = true;
+                continue;
+            }
+
+            const vdIsVoidInit = vd._init && vd._init.isVoidInitializer();
+
+            // Find overlapped fields with the hole [vd.offset .. vd.offset.size()].
+            foreach (j; 0 .. nfields)
+            {
+                if (i == j)
+                    continue;
+                auto v2 = fields[j];
+                if (v2.errors)
+                {
+                    errors = true;
+                    continue;
+                }
+                if (!vd.isOverlappedWith(v2))
+                    continue;
+
+                // vd and v2 are overlapping.
+                vd.overlapped = true;
+                v2.overlapped = true;
+
+                if (!MODimplicitConv(vd.type.mod, v2.type.mod))
+                    v2.overlapUnsafe = true;
+                if (!MODimplicitConv(v2.type.mod, vd.type.mod))
+                    vd.overlapUnsafe = true;
+
+                if (i > j)
+                    continue;
+
+                if (!v2._init)
+                    continue;
+
+                if (v2._init.isVoidInitializer())
+                    continue;
+
+                if (vd._init && !vdIsVoidInit && v2._init)
+                {
+                    .error(loc, "overlapping default initialization for field `%s` and `%s`", v2.toChars(), vd.toChars());
+                    errors = true;
+                }
+                else if (v2._init && i < j)
+                {
+                    .error(v2.loc, "union field `%s` with default initialization `%s` must be before field `%s`",
+                        v2.toChars(), v2._init.toChars(), vd.toChars());
+                    errors = true;
+                }
+            }
+        }
+        return errors;
+    }
+
+    /***************************************
+     * Fill out remainder of elements[] with default initializers for fields[].
+     * Params:
+     *      loc         = location
+     *      elements    = explicit arguments which given to construct object.
+     *      ctorinit    = true if the elements will be used for default initialization.
+     * Returns:
+     *      false if any errors occur.
+     *      Otherwise, returns true and the missing arguments will be pushed in elements[].
+     */
+    final bool fill(Loc loc, Expressions* elements, bool ctorinit)
+    {
+        //printf("AggregateDeclaration::fill() %s\n", toChars());
+        assert(sizeok == Sizeok.done);
+        assert(elements);
+        const nfields = nonHiddenFields();
+        bool errors = false;
+
+        size_t dim = elements.dim;
+        elements.setDim(nfields);
+        foreach (size_t i; dim .. nfields)
+            (*elements)[i] = null;
+
+        // Fill in missing any elements with default initializers
+        foreach (i; 0 .. nfields)
+        {
+            if ((*elements)[i])
+                continue;
+
+            auto vd = fields[i];
+            auto vx = vd;
+            if (vd._init && vd._init.isVoidInitializer())
+                vx = null;
+
+            // Find overlapped fields with the hole [vd.offset .. vd.offset.size()].
+            size_t fieldi = i;
+            foreach (j; 0 .. nfields)
+            {
+                if (i == j)
+                    continue;
+                auto v2 = fields[j];
+                if (!vd.isOverlappedWith(v2))
+                    continue;
+
+                if ((*elements)[j])
+                {
+                    vx = null;
+                    break;
+                }
+                if (v2._init && v2._init.isVoidInitializer())
+                    continue;
+
+                version (all)
+                {
+                    /* Prefer first found non-void-initialized field
+                     * union U { int a; int b = 2; }
+                     * U u;    // Error: overlapping initialization for field a and b
+                     */
+                    if (!vx)
+                    {
+                        vx = v2;
+                        fieldi = j;
+                    }
+                    else if (v2._init)
+                    {
+                        .error(loc, "overlapping initialization for field `%s` and `%s`", v2.toChars(), vd.toChars());
+                        errors = true;
+                    }
+                }
+                else
+                {
+                    // fixes https://issues.dlang.org/show_bug.cgi?id=1432 by enabling this path always
+
+                    /* Prefer explicitly initialized field
+                     * union U { int a; int b = 2; }
+                     * U u;    // OK (u.b == 2)
+                     */
+                    if (!vx || !vx._init && v2._init)
+                    {
+                        vx = v2;
+                        fieldi = j;
+                    }
+                    else if (vx != vd && !vx.isOverlappedWith(v2))
+                    {
+                        // Both vx and v2 fills vd, but vx and v2 does not overlap
+                    }
+                    else if (vx._init && v2._init)
+                    {
+                        .error(loc, "overlapping default initialization for field `%s` and `%s`",
+                            v2.toChars(), vd.toChars());
+                        errors = true;
+                    }
+                    else
+                        assert(vx._init || !vx._init && !v2._init);
+                }
+            }
+            if (vx)
+            {
+                Expression e;
+                if (vx.type.size() == 0)
+                {
+                    e = null;
+                }
+                else if (vx._init)
+                {
+                    assert(!vx._init.isVoidInitializer());
+                    if (vx.inuse)   // https://issues.dlang.org/show_bug.cgi?id=18057
+                    {
+                        vx.error(loc, "recursive initialization of field");
+                        errors = true;
+                    }
+                    else
+                        e = vx.getConstInitializer(false);
+                }
+                else
+                {
+                    if ((vx.storage_class & STC.nodefaultctor) && !ctorinit)
+                    {
+                        .error(loc, "field `%s.%s` must be initialized because it has no default constructor",
+                            type.toChars(), vx.toChars());
+                        errors = true;
+                    }
+                    /* https://issues.dlang.org/show_bug.cgi?id=12509
+                     * Get the element of static array type.
+                     */
+                    Type telem = vx.type;
+                    if (telem.ty == Tsarray)
+                    {
+                        /* We cannot use Type::baseElemOf() here.
+                         * If the bottom of the Tsarray is an enum type, baseElemOf()
+                         * will return the base of the enum, and its default initializer
+                         * would be different from the enum's.
+                         */
+                        TypeSArray tsa;
+                        while ((tsa = telem.toBasetype().isTypeSArray()) !is null)
+                            telem = tsa.next;
+                        if (telem.ty == Tvoid)
+                            telem = Type.tuns8.addMod(telem.mod);
+                    }
+                    if (telem.needsNested() && ctorinit)
+                        e = telem.defaultInit(loc);
+                    else
+                        e = telem.defaultInitLiteral(loc);
+                }
+                (*elements)[fieldi] = e;
+            }
+        }
+        foreach (e; *elements)
+        {
+            if (e && e.op == TOK.error)
+                return false;
+        }
+
+        return !errors;
+    }
+
+    /****************************
+     * Do byte or word alignment as necessary.
+     * Align sizes of 0, as we may not know array sizes yet.
+     * Params:
+     *   alignment = struct alignment that is in effect
+     *   size = alignment requirement of field
+     *   poffset = pointer to offset to be aligned
+     */
+    extern (D) static void alignmember(structalign_t alignment, uint size, uint* poffset) pure nothrow @safe
+    {
+        //printf("alignment = %d, size = %d, offset = %d\n",alignment,size,offset);
+        switch (alignment)
+        {
+        case cast(structalign_t)1:
+            // No alignment
+            break;
+
+        case cast(structalign_t)STRUCTALIGN_DEFAULT:
+            // Alignment in Target::fieldalignsize must match what the
+            // corresponding C compiler's default alignment behavior is.
+            assert(size > 0 && !(size & (size - 1)));
+            *poffset = (*poffset + size - 1) & ~(size - 1);
+            break;
+
+        default:
+            // Align on alignment boundary, which must be a positive power of 2
+            assert(alignment > 0 && !(alignment & (alignment - 1)));
+            *poffset = (*poffset + alignment - 1) & ~(alignment - 1);
+            break;
+        }
+    }
+
+    /****************************************
+     * Place a member (mem) into an aggregate (agg), which can be a struct, union or class
+     * Returns:
+     *      offset to place field at
+     *
+     * nextoffset:    next location in aggregate
+     * memsize:       size of member
+     * memalignsize:  natural alignment of member
+     * alignment:     alignment in effect for this member
+     * paggsize:      size of aggregate (updated)
+     * paggalignsize: alignment of aggregate (updated)
+     * isunion:       the aggregate is a union
+     */
+    extern (D) static uint placeField(uint* nextoffset, uint memsize, uint memalignsize,
+        structalign_t alignment, uint* paggsize, uint* paggalignsize, bool isunion)
+    {
+        uint ofs = *nextoffset;
+
+        const uint actualAlignment =
+            alignment == STRUCTALIGN_DEFAULT ? memalignsize : alignment;
+
+        // Ensure no overflow
+        bool overflow;
+        const sz = addu(memsize, actualAlignment, overflow);
+        addu(ofs, sz, overflow);
+        if (overflow) assert(0);
+
+        alignmember(alignment, memalignsize, &ofs);
+        uint memoffset = ofs;
+        ofs += memsize;
+        if (ofs > *paggsize)
+            *paggsize = ofs;
+        if (!isunion)
+            *nextoffset = ofs;
+
+        if (*paggalignsize < actualAlignment)
+            *paggalignsize = actualAlignment;
+
+        return memoffset;
+    }
+
+    override final Type getType()
+    {
+        return type;
+    }
+
+    // is aggregate deprecated?
+    override final bool isDeprecated() const
+    {
+        return !!(this.storage_class & STC.deprecated_);
+    }
+
+    /// Flag this aggregate as deprecated
+    final void setDeprecated()
+    {
+        this.storage_class |= STC.deprecated_;
+    }
+
+    /****************************************
+     * Returns true if there's an extra member which is the 'this'
+     * pointer to the enclosing context (enclosing aggregate or function)
+     */
+    final bool isNested() const
+    {
+        return enclosing !is null;
+    }
+
+    /* Append vthis field (this.tupleof[$-1]) to make this aggregate type nested.
+     */
+    extern (D) final void makeNested()
+    {
+        if (enclosing) // if already nested
+            return;
+        if (sizeok == Sizeok.done)
+            return;
+        if (isUnionDeclaration() || isInterfaceDeclaration())
+            return;
+        if (storage_class & STC.static_)
+            return;
+
+        // If nested struct, add in hidden 'this' pointer to outer scope
+        auto s = toParentLocal();
+        if (!s)
+            s = toParent2();
+        if (!s)
+            return;
+        Type t = null;
+        if (auto fd = s.isFuncDeclaration())
+        {
+            enclosing = fd;
+
+            /* https://issues.dlang.org/show_bug.cgi?id=14422
+             * If a nested class parent is a function, its
+             * context pointer (== `outer`) should be void* always.
+             */
+            t = Type.tvoidptr;
+        }
+        else if (auto ad = s.isAggregateDeclaration())
+        {
+            if (isClassDeclaration() && ad.isClassDeclaration())
+            {
+                enclosing = ad;
+            }
+            else if (isStructDeclaration())
+            {
+                if (auto ti = ad.parent.isTemplateInstance())
+                {
+                    enclosing = ti.enclosing;
+                }
+            }
+            t = ad.handleType();
+        }
+        if (enclosing)
+        {
+            //printf("makeNested %s, enclosing = %s\n", toChars(), enclosing.toChars());
+            assert(t);
+            if (t.ty == Tstruct)
+                t = Type.tvoidptr; // t should not be a ref type
+
+            assert(!vthis);
+            vthis = new ThisDeclaration(loc, t);
+            //vthis.storage_class |= STC.ref_;
+
+            // Emulate vthis.addMember()
+            members.push(vthis);
+
+            // Emulate vthis.dsymbolSemantic()
+            vthis.storage_class |= STC.field;
+            vthis.parent = this;
+            vthis.visibility = Visibility(Visibility.Kind.public_);
+            vthis.alignment = t.alignment();
+            vthis.semanticRun = PASS.semanticdone;
+
+            if (sizeok == Sizeok.fwd)
+                fields.push(vthis);
+
+            makeNested2();
+        }
+    }
+
+    /* Append vthis2 field (this.tupleof[$-1]) to add a second context pointer.
+     */
+    extern (D) final void makeNested2()
+    {
+        if (vthis2)
+            return;
+        if (!vthis)
+            makeNested();   // can't add second before first
+        if (!vthis)
+            return;
+        if (sizeok == Sizeok.done)
+            return;
+        if (isUnionDeclaration() || isInterfaceDeclaration())
+            return;
+        if (storage_class & STC.static_)
+            return;
+
+        auto s0 = toParentLocal();
+        auto s = toParent2();
+        if (!s || !s0 || s == s0)
+            return;
+        auto cd = s.isClassDeclaration();
+        Type t = cd ? cd.type : Type.tvoidptr;
+
+        vthis2 = new ThisDeclaration(loc, t);
+        //vthis2.storage_class |= STC.ref_;
+
+        // Emulate vthis2.addMember()
+        members.push(vthis2);
+
+        // Emulate vthis2.dsymbolSemantic()
+        vthis2.storage_class |= STC.field;
+        vthis2.parent = this;
+        vthis2.visibility = Visibility(Visibility.Kind.public_);
+        vthis2.alignment = t.alignment();
+        vthis2.semanticRun = PASS.semanticdone;
+
+        if (sizeok == Sizeok.fwd)
+            fields.push(vthis2);
+    }
+
+    override final bool isExport() const
+    {
+        return visibility.kind == Visibility.Kind.export_;
+    }
+
+    /*******************************************
+     * Look for constructor declaration.
+     */
+    final Dsymbol searchCtor()
+    {
+        auto s = search(Loc.initial, Id.ctor);
+        if (s)
+        {
+            if (!(s.isCtorDeclaration() ||
+                  s.isTemplateDeclaration() ||
+                  s.isOverloadSet()))
+            {
+                s.error("is not a constructor; identifiers starting with `__` are reserved for the implementation");
+                errors = true;
+                s = null;
+            }
+        }
+        if (s && s.toParent() != this)
+            s = null; // search() looks through ancestor classes
+        if (s)
+        {
+            // Finish all constructors semantics to determine this.noDefaultCtor.
+            struct SearchCtor
+            {
+                extern (C++) static int fp(Dsymbol s, void* ctxt)
+                {
+                    auto f = s.isCtorDeclaration();
+                    if (f && f.semanticRun == PASS.init)
+                        f.dsymbolSemantic(null);
+                    return 0;
+                }
+            }
+
+            for (size_t i = 0; i < members.dim; i++)
+            {
+                auto sm = (*members)[i];
+                sm.apply(&SearchCtor.fp, null);
+            }
+        }
+        return s;
+    }
+
+    override final Visibility visible() pure nothrow @nogc @safe
+    {
+        return visibility;
+    }
+
+    // 'this' type
+    final Type handleType()
+    {
+        return type;
+    }
+
+    // Does this class have an invariant function?
+    final bool hasInvariant()
+    {
+        return invs.length != 0;
+    }
+
+    // Back end
+    void* sinit;  /// initializer symbol
+
+    override final inout(AggregateDeclaration) isAggregateDeclaration() inout
+    {
+        return this;
+    }
+
+    override void accept(Visitor v)
+    {
+        v.visit(this);
+    }
+}