changelog.dd

Ddoc

$(D_S D Change Log,

$(VERSION 067.0, Mar 24, 2015, =================================================,

$(BUGSTITLE Language Changes,
$(LI $(RELATIVE_LINK2 heap-struct-destructors, Destructors for structs allocated on the heap are now invoked.))
$(LI $(RELATIVE_LINK2 asm-attributes, $(D asm) statements can now be used in $(D pure), $(D nothrow), $(D @nogc), or $(D @trusted) code.))
$(LI $(RELATIVE_LINK2 package-protection, $(D package) protection attribute can be optionally bound to specified package))
)

$(BUGSTITLE Library Changes,
$(LI $(RELATIVE_LINK2 faster-gc-1, The garbage collector got faster.))
$(LI $(RELATIVE_LINK2 volatile-load-store, $(D volatileLoad) and $(D volatileStore) intrinsics were added.))
$(LI $(RELATIVE_LINK2 gc-options, $(B Experimental:) The garbage collector can now be configured.))
$(LI $(RELATIVE_LINK2 aa-keyvalue, $(D byKeyValue) was added.))
$(LI $(LINK2 phobos-prerelease/std_concurrency.html#.initOnce, $(D initOnce) was added to perform thread-safe lazy initialization.))

$(BUGSTITLE Language Changes,

$(LI $(LNAME2 heap-struct-destructors, Destructors for structs allocated on the heap are now invoked.)

    $(P Previously, when a struct allocated on the heap was freed, the destructor was not
        invoked. This is no longer the case, and these destructors will now be invoked
        before the memory is freed by the GC.
    )
)

$(LI $(LNAME2 asm-attributes, $(D asm) statements can now be used in $(D pure), $(D nothrow), $(D @nogc), or $(D @trusted) code.)

    $(P By adding the appropriate attributes to an asm statement you
        can tell the compiler how that asm code behaves, thus allowing asm
        statements to be used in pure, nothrow, @nogc, or @safe functions.

        ---------
        asm pure nothrow @nogc @trusted
        {
            // the compiler does not check the attributes
            ret;
        }
        ---------
    )
)

$(LI $(LNAME2 package-protection, $(D package) protection attribute can be optionally bound to specified package)

    $(P New optional syntax was added for package protection attribute:

        --------
        module aaa.bbb.ccc.ddd;

        // accessible from any module with aaa.bbb in qualified path
        package(aaa.bbb) void foo() {}

        // old style, means same as package(aaa.bbb.ccc)
        package void bar() {}
        ---------
    )
)

)

$(BUGSTITLE Library Changes,

$(LI $(LNAME2 faster-gc-1, This release comes with various GC optimizations that make many applications faster.)

    $(P A new GC growth policy was implemented that helps to reduce the
        number of collections by keeping a collection threshold at 2x the size
        of the used memory. After each collection the used memory and the
        threshold are recomputed. This allows for an exponential growth of the
        GC heap, e.g. during program startup, but limits the heap size relative
        to the actual used memory.
        The factor 2x is configurable by setting $(RELATIVE_LINK2 gc-options, heapSizeFactor).
    )

    $(P The heap traversal during the marking phase is now done using tail
        recursion with a separate compact state stack. This allows to mark very
        deep heaps (lists) much faster because the previous recursion limit of
        50 is eliminated.
    )

    $(P You can see a list of all improvements $(LINK2
        https://github.com/D-Programming-Language/druntime/pulls?q=is:merged+is:pr+label:GC+merged:2014-08-18..2015-03-01,
        here).)

    <img src="images/faster-gc-1.svg" alt="GC benchmarks" style="max-width: 100%">
)

$(LI $(LNAME2 volatile-load-store, $(D volatileLoad) and $(D volatileStore) intrinsics were added.)

    $(P Calls to $(D volatileLoad) and $(D volatileStore) are recognized by
        the compiler and guaranteed to not be removed or reordered in the same
        thread.

        ---------
        void example(uint* address, uint value)
        {
            import core.bitop;

            // store value
            volatileStore(address, value);

            // wait until value takes affect
            while (volatileLoad(address) != value)
            { }
        }
        ---------
    )

    $(P $(B Note:) These intrinsics are currently in core.bitop$(COMMA) but will
        be moved to core.volatile when $(D volatile) is no longer a keyword.
    )
)

$(LI $(LNAME2 gc-options, $(B Experimental:) The garbage collector can now be configured through the command line,
    the environment or by options embedded into the executable.)

    $(P By default, GC options can only be passed on the command line of the program
        to run, e.g.

        ---------
        app "--DRT-gcopt=profile:1 minPoolSize:16" arguments to app
        ---------
     )
     $(P Available GC options are:
        $(UL
        $(LI disable:0|1    - start disabled)
        $(LI profile:0|1    - enable profiling with summary when terminating program)
        $(LI initReserve:N  - initial memory to reserve in MB)
        $(LI minPoolSize:N  - initial and minimum pool size in MB)
        $(LI maxPoolSize:N  - maximum pool size in MB)
        $(LI incPoolSize:N  - pool size increment MB)
        $(LI heapSizeFactor:N - targeted heap size to used memory ratio)
        )
     )
     $(P In addition, --DRT-gcopt=help will show the list of options and their current settings.
     )
     $(P Command line options starting with "--DRT-" are filtered out before calling main,
         so the program will not see them. They are still available via rt_args().
     )
     $(P Configuration via the command line can be disabled by declaring a variable for the
         linker to pick up before using it's default from the runtime:
         ---------
         extern(C) __gshared bool rt_cmdline_enabled = false;
         ---------
     )
     $(P Likewise, declare a boolean rt_envvars_enabled to enable configuration via the
         environment variable "DRT_GCOPT:
         ---------
         extern(C) __gshared bool rt_envvars_enabled = true;
         ---------
     )
     $(P Setting default configuration properties in the executable can be done by specifying an
         array of options named rt_options:
         ---------
         extern(C) __gshared string[] rt_options = [ "gcopt=initReserve:100 profile:1" ];
         ---------
     )
     $(P Evaluation order of options is rt_options, then environment variables, then command
         line arguments, i.e. if command line arguments are not disabled, they can override
         options specified through the environment or embedded in the executable.
     )
)

$(LI $(LNAME2 aa-keyvalue, $(D byKeyValue) was added.)

    $(P Built-in associative arrays now have a $(D .byKeyValue) method that
    returns a forward range iterating over key/value pairs.)

    ------
    void main()
    {
        auto aa = ["a": 1];
        foreach (pair; aa.byKeyValue)
        {
            assert(pair.key == "a");
            assert(pair.value == 1);
        }
    }
    ------
)
)
)

)

$(VERSION 066.1, October 15, 2014, =================================================,

$(BR)$(BIG List of all bug fixes in D 2.066.1.)

$(BUGSTITLE DMD Compiler regressions,

$(P
$(LI $(BUGZILLA 11312): [REG2.063] Avoid auto-dereference for UFCS functions)
$(LI $(BUGZILLA 11946): need 'this' to access member when passing field to template parameter)
$(LI $(BUGZILLA 13294): [IFTI] IFTI fails or works incorrectly for function with const and mutable `ref` parameters of most types)
$(LI $(BUGZILLA 13299): [dmd-2.066-rc2] - Property not found with typesafe variadic opDispatch)
$(LI $(BUGZILLA 13303): Internal error: ..\ztc\cgcs.c 351 with rvalue Variant.get call)
$(LI $(BUGZILLA 13311): [REG2.065] ICE, CtorDeclaration::semantic$(LPAREN)Scope*$(RPAREN): Assertion `tf && tf->ty == Tfunction` failed)
$(LI $(BUGZILLA 13321): Wrong goto skips declaration error)
$(LI $(BUGZILLA 13353): [REG2.066] [ICE] assertion with is$(LPAREN)$(RPAREN) and templated interface)
$(LI $(BUGZILLA 13374): Wrong template overload resolution when passing function to alias/string parameter)
$(LI $(BUGZILLA 13378): Wrong failure of template value parameter deduction in IFTI)
$(LI $(BUGZILLA 13379): Latest dmd fails with recursive template expansion in std.regex)
$(LI $(BUGZILLA 13394): invariant fail to link since 2.066 when using separate compilation)
$(LI $(BUGZILLA 13400): Linking problems with bigints and std.functional.memoize)
$(LI $(BUGZILLA 13415): [REG2.066] '-inline' causes wrong enclosing scope pointer for nested function called from templated struct)
$(LI $(BUGZILLA 13417): [REG2.066] segmentation fault when deduce template type)
$(LI $(BUGZILLA 13424): [REG2.066] Initialization of delegate to do-nothing default causes segfault at runtime)
$(LI $(BUGZILLA 13427): [REG2.066] cannot inline default argument alloca$(LPAREN)...$(RPAREN))
$(LI $(BUGZILLA 13472): [REG2.066] trying to insert a null into an array of object segfaults the compiler)
$(LI $(BUGZILLA 13476): [REG2.065] Writing stubs for dynamically loaded functions no longer works. $(LPAREN)circular reference$(RPAREN))
$(LI $(BUGZILLA 13478): [REG2.066] Templates not emitted when also referenced in speculative contexts)
$(LI $(BUGZILLA 13504): ICE$(LPAREN)backend/cgelem.c 2418$(RPAREN) with "-O -cov")
)
)
$(BUGSTITLE DMD Compiler bugs,

$(P
$(LI $(BUGZILLA 13235): Wrong code on mutually recursive tuple type)
$(LI $(BUGZILLA 13204): recursive alias declaration)
$(LI $(BUGZILLA 13333): Incorrect error ungagging during the resolution of forward references)
$(LI $(BUGZILLA 12503): Bad optimization with scope$(LPAREN)success$(RPAREN) and return statement)
$(LI $(BUGZILLA 13383): wrong code with -O with ints, longs and bitwise operations)
$(LI $(BUGZILLA 13413): dmd does not follow symlink when searching for dmd.conf)
$(LI $(BUGZILLA 13323): UDA applied to import statement causes compilation to fail without error)
)
)
$(BUGSTITLE DMD Compiler enhancements,

$(P
$(LI $(BUGZILLA 12567): Modules can't be marked as deprecated)
)
)
$(BUGSTITLE Phobos regressions,

$(P
$(LI $(BUGZILLA 13618): removing deprecated std.metastrings module breaks code)
)
)
$(BUGSTITLE Phobos bugs,

$(P
$(LI $(BUGZILLA 13313): std.datetime fails unittests on Windows)
)
)
$(BUGSTITLE Druntime regressions,

$(P
$(LI $(BUGZILLA 13399): va_arg is nothrow yet may throw)
)
)
$(BUGSTITLE Druntime bugs,

$(P
$(LI $(BUGZILLA 13377): core/sys/posix/syslog.d is in druntime/src but not in druntime/src/import)
$(LI $(BUGZILLA 13414): Static destructors not called correctly with dynamic loading)
)
)
$(BUGSTITLE Installer regressions,

$(P
$(LI $(BUGZILLA 13233): Windows installer: downloading external installers $(LPAREN)Visual D/dmc$(RPAREN) does not work)
)
)
)

$(VERSION 066.0, August 18, 2014, =================================================,

$(BUGSTITLE Compiler Changes,
$(LI $(RELATIVE_LINK2 warn-unused-retval, $(D -w) now warns about an unused return value of a strongly pure nothrow function call.))
$(LI $(RELATIVE_LINK2 boundscheck, $(D -noboundscheck) has been deprecated in favor of $(D boundscheck=[on|safeonly|off]).))
$(LI $(RELATIVE_LINK2 vgc-switch, $(D -vgc) was added to list GC allocation code positions in the code.))
$(LI $(RELATIVE_LINK2 vcolumns-switch, $(D -vcolumns) was added to display column numbers in error messages.))
$(LI $(RELATIVE_LINK2 color-switch, $(D -color) was added to make console output colored.))
)

$(BUGSTITLE Language Changes,
$(LI $(RELATIVE_LINK2 nogc-attribute, $(D @nogc) attribute was added.))
$(LI $(RELATIVE_LINK2 extern-cpp-nspace, $(D extern $(LPAREN)C++,) $(I namespace)$(D $(RPAREN)) was added.))
$(LI $(RELATIVE_LINK2 opover-multidim-slicing, Operator overloading for multi-dimensional slicing was added.))
$(LI $(RELATIVE_LINK2 traits-getfunctionattributes, $(D __traits$(LPAREN)getFunctionAttributes$(RPAREN)) was added.))
$(LI $(RELATIVE_LINK2 narrowing-conversion-in-ifti, Support template parameter deduction for arguments with a narrowing conversion.))
$(LI $(RELATIVE_LINK2 deprecate-rmw, Read-Modify-Write operations on shared variables are now deprecated.))
$(LI $(RELATIVE_LINK2 uniform-scalar-construction, Support uniform construction syntax for built-in scalar types.))
)

$(BUGSTITLE Library Changes,
$(LI $(RELATIVE_LINK2 duration-split, Duration.get and its wrappers have been deprecated in favor of the new Duration.split.))
$(LI $(RELATIVE_LINK2 array-and-aa-changes, Some built-in type properties have been replaced with library functions.))
$(LI $(RELATIVE_LINK2 aa-key-requirement, Associative array keys now require equality instead of order comparison.))
)

$(BUGSTITLE Linker Changes,
)

$(BR)$(BIG $(RELATIVE_LINK2 list2066, List of all bug fixes and enhancements in D 2.066.))

$(HR)

$(BUGSTITLE Compiler Changes,

$(LI $(LEGACY_LNAME2 warn_unused_retval, warn-unused-retval, $(D -w) now warns about an unused return value of a strongly pure nothrow function call:)

    $(P A discarded return value from a strongly pure nothrow function call now generates a warning.

        ---------
        int foo() pure nothrow { return 1; }
        void main()
        {
            foo();  // the result of foo() is unused
        }
        ---------

        With the $(D -w) switch, the compiler will complain:

        $(CONSOLE Warning: calling foo without side effects discards return value of type int, prepend a cast(void) if intentional)
    )
)

$(LI $(LNAME2 boundscheck, $(D -noboundscheck) has been deprecated in favor of $(D boundscheck=[on|safeonly|off]):)

    $(P Confusion over what the $(D -noboundscheck) command line option did led to the creation of
    the new option $(D -boundscheck=[on|safeonly|off]) which aims to be more clear while enabling
    more flexibility than was present before.
    )

    $(P $(D -boundscheck=)
      $(UL
        $(LI $(B on): Bounds checks are enabled for all code. This is the default.)
        $(LI $(B safeonly): Bounds checks are enabled only in $(D @safe) code.
                            This is the default for $(B -release) builds.)
        $(LI $(B off): Bounds checks are disabled completely (even in $(D @safe)
                       code). This option should be used with caution and as a
                       last resort to improve performance. Confirm turning off
                       $(D @safe) bounds checks is worthwhile by benchmarking.)
      )
    )

    $(P $(B Use $(D -boundscheck=off) to replace instances of $(D -noboundscheck).))

    $(P Prior to this there was no way to enable bounds checking for $(D -release) builds nor any
    way of turning off non-$(D @safe) bounds checking without pulling in everything else $(D
    -release) does.)
)

$(LI $(LEGACY_LNAME2 vgc_switch, vgc-switch, $(D -vgc) was added to list GC allocation code positions in the code):

    $(P Prints all GC-allocation points. Analysis will follow the semantics of
        the new $(D @nogc) attribute.
    )
)

$(LI $(LEGACY_LNAME2 vcolumns_switch, vcolumns-switch, $(D -vcolumns) was added to display column numbers in error messages):

    $(P Diagnostic messages will print the character number from each line head.

        ---------
        int x = missing_name;
        ---------

        Without $(D -vcolumns):

        ---------
        test.d(1): Error: undefined identifier missing_name
        ---------

        With $(D -vcolumns):

        ---------
        test.d(1,9): Error: undefined identifier missing_name
        ---------
    )
)

$(LI $(LEGACY_LNAME2 color_switch, color-switch, $(D -color) was added to make console output colored:)

    $(P Errors, deprecation, and warning messages will be colored.
    )
)

)

$(BUGSTITLE Language Changes,

$(LI $(LEGACY_LNAME2 nogc_attribute, nogc-attribute, $(D @nogc) attribute was added:)

    $(P @nogc attribute disallows GC-heap allocation.

        ---------
        class C {}
        void foo() @nogc
        {
            auto c = new C();   // GC-allocation is disallowed
        }
        ---------
    )
)

$(LI $(LEGACY_LNAME2 extern_cpp_nspace, extern-cpp-nspace, $(D extern $(LPAREN)C++,) $(I namespace)$(D $(RPAREN)) was added):

    $(P To represent a C++ namespace, $(D extern $(LPAREN)C++$(RPAREN)) now takes optional dot-chained identifiers.

        ---------
        extern (C++, a.b.c) int foo();
        ---------

        is equivalent with:

$(CPPCODE
namespace a {
  namespace b {
    namespace c {
      int foo();
    }
  }
}
)
    )
)

$(LI $(LEGACY_LNAME2 opover_multidim_slicing, opover-multidim-slicing, Operator overloading for multi-dimensional slicing was added:)

    $(P Documentation is $(LINK2 operatoroverloading.html#ArrayOps, here).)

    $(P Example code:

        ---------
        struct MyContainer(E)
        {
            E[][] payload;

            this(size_t w, size_t h)
            {
                payload = new E[][](h, w);
            }

            size_t opDollar(size_t dim)()
            {
                return payload[dim].length;
            }

            auto opSlice(size_t dim)(size_t lwr, size_t upr)
            {
                import std.typecons;
                return tuple(lwr, upr);
            }

            void opIndexAssign(A...)(E val, A indices)
            {
                assert(A.length == payload.length);

                foreach (dim, x; indices)
                {
                    static if (is(typeof(x) : size_t))
                    {
                        // this[..., x, ...]
                        payload[dim][x] = val;
                    }
                    else
                    {
                        // this[..., x[0] .. x[1], ...]
                        payload[dim][x[0] .. x[1]] = val;
                    }
                }
            }
        }
        void main()
        {
            import std.stdio;

            auto c = MyContainer!int(4, 3);
            writefln("[%([%(%d%| %)]%|\n %)]", c.payload);
            // [[0 0 0 0]
            //  [0 0 0 0]
            //  [0 0 0 0]]

            c[1 .. 3,
              2,
              0 .. $] = 1;
            /*
            Rewritten as:
            c.opIndexAssign(c.opSlice!0(1, 3),
                            2,
                            c.opSlice!2(0, c.opDollar!2()));
            */

            writefln("[%([%(%d%| %)]%|\n %)]", c.payload);
            // [[0 1 1 0]
            //  [0 0 1 0]
            //  [1 1 1 1]]
        }
        ---------
    )
)

$(LI $(LEGACY_LNAME2 traits_getfunctionattributes, traits-getfunctionattributes, $(D __traits$(LPAREN)getFunctionAttributes$(RPAREN)) was added):

    $(P This can take one argument, either a function symbol, function type, function
        pointer type, or delegate type.

        Examples:

        ---------
        void foo() pure nothrow @safe;
        static assert([__traits(getFunctionAttributes, foo)] == ["pure", "nothrow", "@safe"]);

        ref int bar(int) @property @trusted;
        static assert([__traits(getFunctionAttributes, typeof(&bar))] == ["@property", "ref", "@trusted"]);
        ---------
    )
)

$(LI $(LEGACY_LNAME2 narrowing_conversion_in_ifti, narrowing-conversion-in-ifti, Support template parameter deduction for arguments with a narrowing conversion):

    $(P Implicit Function Template Instantiation will now consider a narrowing conversion
        of function arguments when deducing the template instance parameter types.

        ---------
        void foo(T)(T[] arr, T elem) { ... }
        void main()
        {
            short[] a;
            foo(a, 1);
        }
        ---------

        In 2.065 and earlier, calling $(D foo(a, 1)) was not allowed. From 2.066,
        $(D T) is deduced as $(D short) by considering a narrowing conversion
        of the second function argument `1` from $(D int) to $(D short).
    )
)

$(LI $(LEGACY_LNAME2 deprecate_rmw, deprecate-rmw, Read-Modify-Write operations on shared variables are now deprecated):

    $(P Examples:

        ---------
        shared int global;
        void main()
        {
            global++;       // deprecated
            global *= 2;    // deprecated
        }
        ---------

        Instead you should use $(D atomicOp) from $(D core.atomic):

        ---------
        shared int global;
        void main()
        {
            import core.atomic;
            atomicOp!"+="(global, 1);
            atomicOp!"*="(global, 2);
        }
        ---------
    )
)

$(LI $(LEGACY_LNAME2 uniform_scalar_construction, uniform-scalar-construction, Support uniform construction syntax for built-in scalar types):

    $(P Examples:

        ---------
        short n1 = 1;
        auto n2 = short(1); // equivalent with n1, typeof(n2) is short

        auto p1 = new long(1);                  // typeof(p1) is long*
        auto p2 = new immutable double(3.14);   // typeof(p2) is immutable(double)*
        ---------
    )

    $(P The constructor argument should be implicitly convertible to the constructed type.

        ---------
        auto n1 = short(32767); // OK
        auto n2 = short(32768); // Not allowed, out of bounds of signed short -32768 to 32767
        ---------
    )
)

)

$(BUGSTITLE Library Changes,

$(LI $(LEGACY_LNAME2 duration_split, duration-split, Duration.get and its wrappers have been deprecated in favor of the new Duration.split:)

    $(P $(CXREF time, Duration.get) and its wrappers, $(CXREF time, Duration.weeks),
        $(CXREF time, Duration.days), $(CXREF time, Duration.hours), and
        $(CXREF time, Duration.seconds), as well as $(CXREF time, Duration.fracSec) (which
        served a similar purpose as $(CXREF time, Duration.get) for the fractional second units)
        have proven to be too easily confused with $(CXREF time, Duration.total), causing
        subtle bugs. So, they have been deprecated. In their place, $(CXREF time, Duration.split)
        has been added - and it's not only very useful, but it does a great job of showing off
        what D can do.

        Whereas $(CXREF time, Duration.get) split out all of the units of a
        $(CXREF time, Duration) and then returned only one of them,
        $(CXREF time, Duration.split) splits out a $(CXREF time, Duration) into the units
        that it's told to (which could be one unit or all of them) and returns all of
        them. It has two overloads, both which take template arguments that indicate which
        of the units are to be split out. The difference is in how the result is returned.

        As with most of the templates in core.time and std.datetime which take strings
        to represent units, $(CXREF time, Duration.split) accepts $(D "weeks"), $(D "days"),
        $(D "hours"), $(D "minutes"), $(D "seconds"), $(D "msecs"), $(D "usecs"),
        $(D "hnsecs"), and $(D "nsecs").

        The first overload returns the split out units as $(D out) parameters.

        ---------
        auto d = weeks(5) + days(4) + hours(17) + seconds(2) + hnsecs(12_007);
        short days;
        long seconds;
        int msecs;
        d.split!("days", "seconds", "msecs")(days, seconds, msecs);
        assert(days == 39);
        assert(seconds == 61_202);
        assert(msecs == 1);
        ---------

        The arguments can be any integral type (though no protection is given against integer
        overflow, so unless it's known that the values are going to be small, it's unwise to
        use a small integral type for any of the arguments).

        The second overload returns a struct with the unit names as its fields. Only the
        requested units are present as fields. All of the struct's fields are $(D long)s.

        ---------
        auto d = weeks(5) + days(4) + hours(17) + seconds(2) + hnsecs(12_007);
        auto result = d.split!("days", "seconds", "msecs")();
        assert(result.days == 39);
        assert(result.seconds == 61_202);
        assert(result.msecs == 1);
        ---------

        Or if no units are given to the second overload, then it will return a struct with
        all of the units save for $(D nsecs) (since $(D nsecs) would always be $(D 0) when
        $(D hnsecs) is one of the units as $(CXREF time, Duration) has hnsec precision).

        ---------
        auto d = weeks(5) + days(4) + hours(17) + seconds(2) + hnsecs(12_007);
        auto result = d.split();
        assert(result.weeks == 5);
        assert(result.days == 4);
        assert(result.hours == 17);
        assert(result.minutes == 0);
        assert(result.seconds == 2);
        assert(result.msecs == 1);
        assert(result.usecs == 200);
        assert(result.hnsecs == 7);
        ---------

        Calling $(CXREF time, Duration.get) or its wrappers for each of the units would be
        equivalent to that example, only less efficient when more than one unit is
        requested, as the calculations would have to be done more than once. The exception
        is $(CXREF time, Duration.fracSec) which would have given the total of the
        fractional seconds as the requested units rather than splitting them out.

        ---------
        // Equivalent to previous example
        auto d = weeks(5) + days(4) + hours(17) + seconds(2) + hnsecs(12_007);
        assert(d.weeks == 5);
        assert(d.days == 4);
        assert(d.hours == 17);
        assert(d.minutes == 0);
        assert(d.seconds == 2);
        assert(d.fracSec.msecs == 1);
        assert(d.fracSec.usecs == 1200);
        assert(d.fracSec.hnsecs == 12_007);
        ---------

        It is hoped that $(CXREF time, Duration.split) will be less confusing and thus
        result in fewer bugs, but it's definitely the case that it's more powerful. It's
        also a great example of D's metaprogramming capabilities given how it splits out
        only the requested units and even is able to return a struct with fields with the
        same names as the requested units. This on top of being able to handle a variety
        of integral types as arguments. And its implemenation isn't even very complicated.
    )

)

$(LI $(LEGACY_LNAME2 array_and_aa_changes, array-and-aa-changes, Some built-in type properties have been replaced with library functions:)

    $(P Built-in array properties $(D dup) and $(D idup) were replaced with
        (module-scoped) free functions in the $(D object) module, thanks to D's support of
        $(LINK2 function.html#pseudo-member, Uniform Function Call Syntax).
    )

    $(P Built-in associative array properties $(D rehash), $(D dup), $(D byKey),
        $(D byValue), $(D keys), $(D values), and $(D get) were also replaced with free
        functions in the $(D object) module.
    )
)

$(LI $(LEGACY_LNAME2 aa_key_requirement, aa-key-requirement, Associative array keys now require equality rather than ordering:)

    $(P Until 2.065, opCmp was used to customize the comparison of AA struct keys.

        ---------
        void main()
        {
            int[MyKey] aa;
        }

        struct MyKey
        {
            int x;
            int y;  // want to be ignored for AA key comparison

            int opCmp(ref const MyKey rhs) const
            {
                if (this.x == rhs.x)
                    return 0;

                // defined order was merely unused for AA keys.
                return this.x > rhs.x ? 1 : -1;
            }
        }
        ---------

        From 2.066, the AA implementation has been changed to use the equality operator ($(D ==))
        for the key comparison. So the $(D MyKey) struct should be modified to:

        ---------
        struct MyKey
        {
            int x;
            int y;  // want to be ignored for AA key comparison

            int opEquals(ref const MyKey rhs) const
            {
                return this.x == rhs.x;
            }
        }
        ---------
    )
)

)

$(BR)$(BIG $(LNAME2 list2066, List of all bug fixes and enhancements in D 2.066:))

$(BUGSTITLE DMD Compiler regressions,

$(P
$(LI $(BUGZILLA 5105): Member function template cannot be synchronized)
$(LI $(BUGZILLA 9449): Static arrays of 128bit types segfault on initialization. Incorrect calling of memset128ii.)
$(LI $(BUGZILLA 11777): [ICE] dmd memory corruption as `Scope::pop` `free`s `fieldinit` used also in `enclosing`)
$(LI $(BUGZILLA 12174): Problems caused by enum predicate with std.algorithm.sum)
$(LI $(BUGZILLA 12179): [ICE]$(LPAREN)e2ir.c 1861$(RPAREN) with array operation)
$(LI $(BUGZILLA 12242): conflict error with public imports)
$(LI $(BUGZILLA 12243): [REG 2.065.0] "ICE: cannot append 'char' to 'string'" with -inline)
$(LI $(BUGZILLA 12250): [REG 2.065.0][ICE]$(LPAREN)e2ir.c 2077$(RPAREN) with inout T[] and array operation)
$(LI $(BUGZILLA 12255): Regression: opCmp requirement for AAs breaks code)
$(LI $(BUGZILLA 12262): [REG2.065] A specialized parameter `alias a : B!A` should not match to the non-eponymous instantiated variable)
$(LI $(BUGZILLA 12264): [REG2.066a] A specialized alias parameter conflicts with the unspecialized one.)
$(LI $(BUGZILLA 12266): Regression $(LPAREN)2.065$(RPAREN): Header generation produces uncompilable header)
$(LI $(BUGZILLA 12296): [REG2.066a] const compatible AA pointer conversion is wrongly rejected in CTFE)
$(LI $(BUGZILLA 12312): Regression $(LPAREN)2.064$(RPAREN): Diagnostic for void static arrays has gone bad)
$(LI $(BUGZILLA 12316): GIT HEAD: AA.get broken for Object VAL types)
$(LI $(BUGZILLA 12376): ICE with constarainted template instantiation with error gagging)
$(LI $(BUGZILLA 12382): `opDollar` can't be used at CT)
$(LI $(BUGZILLA 12390): [REG2.066a] "has no effect in expression" diagnostic regression)
$(LI $(BUGZILLA 12396): Regression: major breakage from new import rules)
$(LI $(BUGZILLA 12399): Static and selective import acts like a normal import)
$(LI $(BUGZILLA 12400): Misleading/useless diagnostic on bad fully-qualified symbol name)
$(LI $(BUGZILLA 12403): [AA] Associative array `get` function rejects some cases)
$(LI $(BUGZILLA 12405): Named imports act like regular imports)
$(LI $(BUGZILLA 12413): Infinite recursion of `Package::search`)
$(LI $(BUGZILLA 12467): Regression $(LPAREN)2.066 git-head$(RPAREN): char[] is implicitly convertible to string)
$(LI $(BUGZILLA 12485): [REG2.065] DMD crashes when recursive template expansion)
$(LI $(BUGZILLA 12497): [REG2.064] ICE on string mixin with non-string operand)
$(LI $(BUGZILLA 12501): Assertion `global.gaggedErrors || global.errors` failed.)
$(LI $(BUGZILLA 12509): Compiler performance highly depends on declared array size - for struct with long static array of structs)
$(LI $(BUGZILLA 12554): [ICE]$(LPAREN)struct.c line 898$(RPAREN) with failed delegate purity)
$(LI $(BUGZILLA 12574): [ICE]$(LPAREN)statement.c, line 713$(RPAREN) with reduce with wrong tuple arity)
$(LI $(BUGZILLA 12580): [REG2.066a] dup$(LPAREN)$(RPAREN) won't accept void[])
$(LI $(BUGZILLA 12581): [ICE]$(LPAREN)statement.c, line 713$(RPAREN) with invalid assignment + alias this)
$(LI $(BUGZILLA 12585): Regression$(LPAREN)2.064$(RPAREN): Segfault on lazy/catch/opIndex)
$(LI $(BUGZILLA 12591): [DMD|REG] std/typecons.d$(LPAREN)440$(RPAREN): Error: tuple has no effect in expression)
$(LI $(BUGZILLA 12593): [REG2.065] AA cannot have struct as key)
$(LI $(BUGZILLA 12619): Invalid warning for unused return value of debug memcpy)
$(LI $(BUGZILLA 12649): "discards return value" warning will cause ICE on function pointer call)
$(LI $(BUGZILLA 12650): Invalid codegen on taking lvalue of instance field initializ)
$(LI $(BUGZILLA 12689): [CTFE] assigning via pointer from 'in' expression doesn't work)
$(LI $(BUGZILLA 12703): GIT HEAD : final class rejects members initialization)
$(LI $(BUGZILLA 12719): struct.c:705: virtual void StructDeclaration::semantic$(LPAREN)Scope*$(RPAREN): Assertion `parent && parent == sc->parent` failed.)
$(LI $(BUGZILLA 12727): [REG2.066a] DMD hangs up on recursive alias declaration)
$(LI $(BUGZILLA 12728): [REG2.066a] IFTI should consider instantiated types that has template parameters with default args)
$(LI $(BUGZILLA 12760): Initializing an object that has "this$(LPAREN)Args$(RPAREN) inout" causes "discards return value" warning)
$(LI $(BUGZILLA 12769): ICE returning array)
$(LI $(BUGZILLA 12774): REG$(LPAREN)2.066$(RPAREN) ICE$(LPAREN)optimize.c$(RPAREN) Newing struct containing union causes segfault)
$(LI $(BUGZILLA 12824): REG$(LPAREN)2.066$(RPAREN) ICE$(LPAREN)statement.c$(RPAREN) Segfault with label and static if)
$(LI $(BUGZILLA 12860): REG 2.065: typeid$(LPAREN)_error_$(RPAREN) symbols leaked to backend)
$(LI $(BUGZILLA 12864): can no longer use toLower in string switch case)
$(LI $(BUGZILLA 12880): [REG2.066a] Wrong IFTI for string.init argument)
$(LI $(BUGZILLA 12896): ld.gold complains about bad relocations when building libphobos2.so)
$(LI $(BUGZILLA 12900): REG 2.065: Wrong code in IfStatement condition Expression)
$(LI $(BUGZILLA 12904): Wrong-code for some slice to slice assignments when using `opDollar`)
$(LI $(BUGZILLA 12906): [CTFE] Static array of structs causes postblit call)
$(LI $(BUGZILLA 12910): [AA] `rehash` is incorrectly inferred as strongly pure for some associative arrays)
$(LI $(BUGZILLA 12924): deprecated$(LPAREN)"foo"$(RPAREN); and deprecated; should not compile)
$(LI $(BUGZILLA 12956): [ICE] Assertion in expression.c:432)
$(LI $(BUGZILLA 12981): Can't refer to 'outer' from mixin template)
$(LI $(BUGZILLA 12989): Wrong x86_64 code for delegate return when compiled as lib $(LPAREN)-lib$(RPAREN))
$(LI $(BUGZILLA 13002): DMD 2.066 prep: 32-bit build fails on Ubuntu via create_dmd_release)
$(LI $(BUGZILLA 13008): [REG2.066a] 'deprecated' is not allowed to refer another deprecated when it is a function declaration)
$(LI $(BUGZILLA 13021): Constructing union with floating type and then accessing its field in one expression causes ICE)
$(LI $(BUGZILLA 13024): [ICE]$(LPAREN)expression.c line 1172$(RPAREN) with implicit supertype conversion of different enums in array literal)
$(LI $(BUGZILLA 13025): Tools repository does not build on Ubuntu)
$(LI $(BUGZILLA 13026): object.get cannot be called with [] as "defaultValue" argument)
$(LI $(BUGZILLA 13027): Assertion `ex->op == TOKblit || ex->op == TOKconstruct` failed.)
$(LI $(BUGZILLA 13030): DMD assertion fails at mtype.c:697 if delegate has an argument name)
$(LI $(BUGZILLA 13034): [Reg] core.stdc.stdio - deprecation warning with dmd -inline)
$(LI $(BUGZILLA 13053): Wrong warning on implicitly generated __xtoHash)
$(LI $(BUGZILLA 13056): [2.066.0-b1] Regression: Error: template std.path.baseName cannot deduce function from argument types !$(LPAREN)$(RPAREN)$(LPAREN)DirEntry$(RPAREN))
$(LI $(BUGZILLA 13071): [ICE] dmd 2.066.0-b1 assertion in nogc.c:73)
$(LI $(BUGZILLA 13077): [dmd 2.066-b2] std.range.array with shared InputRangeObject)
$(LI $(BUGZILLA 13081): ICE with alias this and opSlice)
$(LI $(BUGZILLA 13087): Error: no property 'xyz' for type 'Vec!4')
$(LI $(BUGZILLA 13102): Cannot parse 184467440737095516153.6L)
$(LI $(BUGZILLA 13113): cannot build druntime's gc.d with -debug=INVARIANT, bad @nogc inference?)
$(LI $(BUGZILLA 13114): old opCmp requirement for AA keys should be detected for classes)
$(LI $(BUGZILLA 13117): Executable size of hello world explodes from 472K to 2.7M)
$(LI $(BUGZILLA 13127): Cannot deduce function with int[][] argument and "in" parameter)
$(LI $(BUGZILLA 13132): ICE on interface AA key)
$(LI $(BUGZILLA 13141): array cast from string[] to immutable$(LPAREN)char[][]$(RPAREN) is not supported at compile time)
$(LI $(BUGZILLA 13152): [REG2.064.2] Compiler high cpu usage and never ends)
$(LI $(BUGZILLA 13154): Incorrect init of static float array when sliced)
$(LI $(BUGZILLA 13158): "void has no value" in std.variant.Algebraic $(LPAREN)affects D:YAML$(RPAREN))
$(LI $(BUGZILLA 13178): Duplicate symbol of compiler generated symbols)
$(LI $(BUGZILLA 13179): AA key type TagIndex now requires equality rather than comparison)
$(LI $(BUGZILLA 13180): [REG2.066a] AA get returns const$(LPAREN)char[]$(RPAREN) instead of string)
$(LI $(BUGZILLA 13187): Function wrongly deduced as pure)
$(LI $(BUGZILLA 13193): Extreme slowdown in compilation time of OpenSSL in Tango for optimized build)
$(LI $(BUGZILLA 13201): Wrong "Warning: statement is not reachable" error with -w)
$(LI $(BUGZILLA 13208): [ICE]$(LPAREN)e2ir.c 2077$(RPAREN) with array operation)
$(LI $(BUGZILLA 13218): [ICE] s2ir.c 142: Must fully qualify call to ParameterTypeTuple)
$(LI $(BUGZILLA 13219): segmentation fault in FuncDeclaration::getLevel)
$(LI $(BUGZILLA 13220): [ICE] 'global.gaggedErrors || global.errors' on line 750 in file 'statement.c')
$(LI $(BUGZILLA 13221): [ICE] '0' on line 318 in file 'interpret.c')
$(LI $(BUGZILLA 13223): Cannot deduce argument for array template parameters)
$(LI $(BUGZILLA 13232): dmd compile times increased by 10-20%)
$(LI $(BUGZILLA 13237): Wrong code with "-inline -O")
$(LI $(BUGZILLA 13245): segfault when instantiating template with non-compiling function literal)
$(LI $(BUGZILLA 13252): ParameterDefaultValueTuple affects other instantiations)
$(LI $(BUGZILLA 13259): [ICE] 'v.result' on line 191 in file 'todt.c')
$(LI $(BUGZILLA 13284): [dmd 2.066-rc2] Cannot match shared classes at receive)
)
)
$(BUGSTITLE DMD Compiler bugs,

$(P
$(LI $(BUGZILLA 648): DDoc: unable to document mixin statement)
$(LI $(BUGZILLA 846): Error 42: Symbol Undefined "$(LESS)mangle_of_class_template$(GREATER)__arrayZ")
$(LI $(BUGZILLA 1659): template alias parameters are chosen over all but exact matches.)
$(LI $(BUGZILLA 2427): Function call in struct initializer fails to compile)
$(LI $(BUGZILLA 2438): Cannot get types of delegate properties)
$(LI $(BUGZILLA 2456): "cannot put catch statement inside finally block", missing line number)
$(LI $(BUGZILLA 2711): -H produces bad headers files if function defintion is templated and have auto return value)
$(LI $(BUGZILLA 2791): port.h and port.c are missing licenses)
$(LI $(BUGZILLA 3032): No stack allocation for "scope c = new class Object {};")
$(LI $(BUGZILLA 3109): [meta] Template ordering)
$(LI $(BUGZILLA 3490): DMD Never Inlines Functions that Could Throw)
$(LI $(BUGZILLA 3672): [tdpl] read-modify-write $(LPAREN)rmw$(RPAREN) operators must be disabled for shared)
$(LI $(BUGZILLA 4225): mangle.c:81: char* mangle$(LPAREN)Declaration*$(RPAREN): Assertion `fd && fd->inferRetType` failed.)
$(LI $(BUGZILLA 4423): [tdpl] enums of struct types)
$(LI $(BUGZILLA 4757): A forward reference error with return of inner defined struct)
$(LI $(BUGZILLA 4791): Assigning a static array to itself should be allowed)
$(LI $(BUGZILLA 5030): Operators don't work with AssociativeArray!$(LPAREN)T1,T2$(RPAREN))
$(LI $(BUGZILLA 5095): Error for typesafe variadic functions for structs)
$(LI $(BUGZILLA 5498): wrong common type deduction for array of classes)
$(LI $(BUGZILLA 5635): Code inside 'foreach' using opApply cannot modify variable out of its scope in a template function.)
$(LI $(BUGZILLA 5810): Struct postincrement generates 'no effect' error if used on struct member)
$(LI $(BUGZILLA 5835): `TypeInfo_Array.getHash` creates raw data hash instead using array element hash function)
$(LI $(BUGZILLA 5854): Built-in array sort doesn't sort SysTime correctly)
$(LI $(BUGZILLA 6140): Wrong ambiguity error with overloading)
$(LI $(BUGZILLA 6359): Pure/@safe-inference should not be affected by __traits$(LPAREN)compiles$(RPAREN))
$(LI $(BUGZILLA 6430): Overloaded auto-return functions each with a nested aggregate of the same name are conflated)
$(LI $(BUGZILLA 6677): static this attributes position)
$(LI $(BUGZILLA 6889): "finally" mentioned in a compilation error, instead of "scope$(LPAREN)exit$(RPAREN)" or "scope$(LPAREN)success$(RPAREN)")
$(LI $(BUGZILLA 7019): implicit constructors are inconsistently allowed)
$(LI $(BUGZILLA 7209): Stack overflow on explicitly typed enum circular dependency)
$(LI $(BUGZILLA 7469): template mangling depends on instantiation order)
$(LI $(BUGZILLA 7477): Enum structs without specified values)
$(LI $(BUGZILLA 7870): Shared library support for Linux is missing)
$(LI $(BUGZILLA 7887): [CTFE] can't assign to returned reference)
$(LI $(BUGZILLA 8100): [ICE] with templated subclassing)
$(LI $(BUGZILLA 8236): Wrong error message in creating struct from vector operation)
$(LI $(BUGZILLA 8254): nested struct cannot access the types of the parent's fields)
$(LI $(BUGZILLA 8269): The 'with statement' does not observe temporary object lifetime)
$(LI $(BUGZILLA 8296): @disable this propagates through reference)
$(LI $(BUGZILLA 8309): ICE in typeMerge on 'void main$(LPAREN)$(RPAREN){auto x = [$(LPAREN)$(RPAREN)=>1.0, $(LPAREN)$(RPAREN)=>1];}')
$(LI $(BUGZILLA 8370): invalid deprecation error with -release -inline -noboundscheck)
$(LI $(BUGZILLA 8373): IFTI fails on overloading of function vs non function template)
$(LI $(BUGZILLA 8392): DMD sometime fail when using a non static function template within a function template)
$(LI $(BUGZILLA 8499): ICE on undefined identifier)
$(LI $(BUGZILLA 8596): Indeterministic assertion failure in rehash)
$(LI $(BUGZILLA 8704): Invalid nested struct constructions should be detected)
$(LI $(BUGZILLA 8738): Struct literal breaks assigment ordering)
$(LI $(BUGZILLA 9245): [CTFE] postblit not called on static array initialization)
$(LI $(BUGZILLA 9596): Ambiguous match is incorrectly hidden by additional lesser match)
$(LI $(BUGZILLA 9708): inout breaks zero parameter IFTI)
$(LI $(BUGZILLA 9931): Mac OS X ABI not followed when returning structs for extern $(LPAREN)C$(RPAREN))
$(LI $(BUGZILLA 10054): x86_64 valgrind reports unrecognised instruction $(LPAREN)DMD 2.062$(RPAREN))
$(LI $(BUGZILLA 10071): 'real' alignment wrong on several platforms)
$(LI $(BUGZILLA 10112): Mangle, which defined by pragma$(LPAREN)mangle$(RPAREN) should not be mangled by backend.)
$(LI $(BUGZILLA 10133): ICE for templated static conditional lambda)
$(LI $(BUGZILLA 10169): duplicate error message: member is not accessible)
$(LI $(BUGZILLA 10219): Implicit conversion between delegates returning a class and an interface)
$(LI $(BUGZILLA 10366): Ddoc: Symbols in template classes don't get fully qualified anchors)
$(LI $(BUGZILLA 10629): [ICE]$(LPAREN)dt.c 106$(RPAREN) with void array)
$(LI $(BUGZILLA 10658): Cannot merge template overload set by using alias declaration)
$(LI $(BUGZILLA 10703): Front-end code removal "optimisation" with try/catch blocks produces wrong codegen)
$(LI $(BUGZILLA 10908): Links in d.chm file are broken)
$(LI $(BUGZILLA 10928): Fails to create closures that reference structs with dtor)
$(LI $(BUGZILLA 10985): Compiler doesn't attempt to inline non-templated functions from libraries $(LPAREN)even having the full source$(RPAREN))
$(LI $(BUGZILLA 11066): Spurious warning 'statement is not reachable' with -profile)
$(LI $(BUGZILLA 11177): parameterized enum can't be typed)
$(LI $(BUGZILLA 11181): Missing compile-time error for wrong array literal)
$(LI $(BUGZILLA 11201): ICE: $(LPAREN)symbol.c$(RPAREN) -inline stops compilation)
$(LI $(BUGZILLA 11333): ICE: Cannot subtype 0-tuple with "alias this")
$(LI $(BUGZILLA 11421): Dynamic array of associative array literal type inference)
$(LI $(BUGZILLA 11448): `dup` calls @system impure code from @safe pure function)
$(LI $(BUGZILLA 11453): Compiling packages has a dependency on order of modules passed to the compiler.)
$(LI $(BUGZILLA 11511): DDoc - C variadic parameters cannot be properly documented)
$(LI $(BUGZILLA 11535): CTFE ICE on reassigning a static array initialized with block assignment)
$(LI $(BUGZILLA 11542): scope$(LPAREN)failure$(RPAREN) messes up nothrow checking)
$(LI $(BUGZILLA 11543): multiple definition of std.regex with shared library)
$(LI $(BUGZILLA 11545): Aggregate function literal member should not have access to enclosing scope)
$(LI $(BUGZILLA 11550): [ICE] Checking if std.conv.to compiles with an array of non-builtins results in an ICE in s2ir.c.)
$(LI $(BUGZILLA 11622): Assertion failure in totym$(LPAREN)$(RPAREN), glue.c, line 1288)
$(LI $(BUGZILLA 11672): default initialization of static array of structs with a single value fails)
$(LI $(BUGZILLA 11677): user defined attributes must be first)
$(LI $(BUGZILLA 11678): user defined attributes cannot appear as postfixes)
$(LI $(BUGZILLA 11679): user defined attributes not allowed for local auto declarations)
$(LI $(BUGZILLA 11680): user defined attributes for type inference)
$(LI $(BUGZILLA 11735): pragma$(LPAREN)msg, ...$(RPAREN) fails to print wstring, dstring)
$(LI $(BUGZILLA 11740): [64-bit] Struct with constructor incorrectly passed on stack to extern$(LPAREN)C++$(RPAREN) function)
$(LI $(BUGZILLA 11752): Make issues.dlang.org work)
$(LI $(BUGZILLA 11774): Lambda argument to templated function changes its signature forever)
$(LI $(BUGZILLA 11783): Make std.datetime unittesting faster)
$(LI $(BUGZILLA 11788): [x86] Valgrind unhandled instruction bytes: 0xC8 0x8 0x0 0x0)
$(LI $(BUGZILLA 11832): std.datetime: ddoc warnings)
$(LI $(BUGZILLA 11872): Support for overloaded template functions in with block)
$(LI $(BUGZILLA 11885): ICE$(LPAREN)s2ir.c 359$(RPAREN) with continuing a labeled ByLine $(LPAREN)range struct w/ dtor$(RPAREN) loop)
$(LI $(BUGZILLA 11889): std.container.Array.opIndex returns by value, resulting in perfect storm)
$(LI $(BUGZILLA 11901): real win64)
$(LI $(BUGZILLA 11906): Compiler assertion when comparing function pointers)
$(LI $(BUGZILLA 12009): local import and "unable to resolve forward reference" error)
$(LI $(BUGZILLA 12011): "Internal Compiler Error: Null field" on CTFE method call on .init)
$(LI $(BUGZILLA 12042): "CTFE internal error: Dotvar assignment" with template method and "with")
$(LI $(BUGZILLA 12057): [ICE], backend/cg87.c 925)
$(LI $(BUGZILLA 12063): No line number error on uninitialized enum member if base type is not incrementable)
$(LI $(BUGZILLA 12077): Instantiated type does not match to the specialized alias parameter)
$(LI $(BUGZILLA 12078): forward reference issue with is$(LPAREN)$(RPAREN) and curiously recurring template pattern)
$(LI $(BUGZILLA 12110): [CTFE]  Error: CTFE internal error: Dotvar assignment)
$(LI $(BUGZILLA 12138): Label statement creates an unexpected scope block)
$(LI $(BUGZILLA 12143): Base class is forward referenced)
$(LI $(BUGZILLA 12164): Function returning ptrdiff_t.min in 64-bit returning 0 when -O is set.)
$(LI $(BUGZILLA 12212): Static array assignment makes slice implicitly)
$(LI $(BUGZILLA 12231): ICE on the class declaration within lambda inside template constraint)
$(LI $(BUGZILLA 12235): ICE on printing mangled name of forward reference lambda by pragma$(LPAREN)msg$(RPAREN))
$(LI $(BUGZILLA 12236): Inconsistent mangleof result)
$(LI $(BUGZILLA 12237): Inconsistent behavior of the instantiating enclosing template function)
$(LI $(BUGZILLA 12263): Specialized template parameter incorrectly fail to match to the same name template.)
$(LI $(BUGZILLA 12278): __traits$(LPAREN)classInstanceSize$(RPAREN) returns wrong value if used before class is declared)
$(LI $(BUGZILLA 12287): infinite loop on std.traits.moduleName on templated struct member)
$(LI $(BUGZILLA 12292): Template specialization ": string" passes for static arrays of other types)
$(LI $(BUGZILLA 12302): Assertion failure in expression.c $(LPAREN)line 432$(RPAREN)  when using template isCallable)
$(LI $(BUGZILLA 12306): Struct Enums cannot be read at compile time)
$(LI $(BUGZILLA 12307): Contextfull error diagnostic about AA key type)
$(LI $(BUGZILLA 12313): Unneeded stack temporaries created by tuple foreach)
$(LI $(BUGZILLA 12334): Cannot access frame pointer of nested class from inside lambda)
$(LI $(BUGZILLA 12350): Assigning __traits$(LPAREN)getAttributes$(RPAREN) to variable crashes DMD)
$(LI $(BUGZILLA 12362): dmd hangs when attempting to use undefined enum)
$(LI $(BUGZILLA 12378): Compiler accepts any syntactically-valid code inside double-nested map predicate)
$(LI $(BUGZILLA 12392): No attribute inference if first template instantiation uses `alias`)
$(LI $(BUGZILLA 12397): CTFE ICE CompiledCtfeFunction::walkAllVars with 2.065)
$(LI $(BUGZILLA 12432): Diagnostic on argument count mismatch for ranges and opApply should improve)
$(LI $(BUGZILLA 12436): Opaque struct parameter type should not be allowed)
$(LI $(BUGZILLA 12460): Crash with goto and static if)
$(LI $(BUGZILLA 12476): Assert error in interpret.c:3204)
$(LI $(BUGZILLA 12480): static assert should print out the string representation of a value it can interpret)
$(LI $(BUGZILLA 12498): ICE: while$(LPAREN)string$(RPAREN) causes compiler to crash during CTFE)
$(LI $(BUGZILLA 12499): tuple/TypeTuple 1-Arg initialization fails during CTFE.)
$(LI $(BUGZILLA 12503): Bad optimization with scope$(LPAREN)success$(RPAREN) and return statement)
$(LI $(BUGZILLA 12506): Wrongly private lambda to define global immutable array)
$(LI $(BUGZILLA 12508): Codegen bug for interface type covariant return with lambda type inference)
$(LI $(BUGZILLA 12523): wrong foreach argument type with ref and inout)
$(LI $(BUGZILLA 12524): wrong type with inout const arg and inout return)
$(LI $(BUGZILLA 12528): [CTFE] cannot append elements from one inout array to another inout array)
$(LI $(BUGZILLA 12534): ICE on using expression tuple as type tuple)
$(LI $(BUGZILLA 12539): Compiler crash when looking up a nonexistent tuple element in an associative array)
$(LI $(BUGZILLA 12542): No function attribute inference for recursive functions)
$(LI $(BUGZILLA 12543): Class.sizeof requires the Class' definition)
$(LI $(BUGZILLA 12555): Incorrect error ungagging for speculatively instantiated class)
$(LI $(BUGZILLA 12571): __traits$(LPAREN)parent$(RPAREN) should work for typed manifest constant in initializer)
$(LI $(BUGZILLA 12577): ice on compile time struct field access)
$(LI $(BUGZILLA 12586): redundant error messages for tuple index exceeding)
$(LI $(BUGZILLA 12602): [CTFE] Changes to an array slice wrapped in a struct do not propogate to the original)
$(LI $(BUGZILLA 12604): No "mismatched array lengths" error with narrowing conversions)
$(LI $(BUGZILLA 12622): Purity, @safe not checked for pointers to functions)
$(LI $(BUGZILLA 12630): @nogc should recognize compile-time evaluation context)
$(LI $(BUGZILLA 12640): Error inside a switch statement causes a spurious switch case fallthrough warning)
$(LI $(BUGZILLA 12642): Avoid some heap allocation cases for fixed-size arrays)
$(LI $(BUGZILLA 12651): TemplateArgsOf accepts nonsensical arguments)
$(LI $(BUGZILLA 12660): Wrong non-@nogc function invariant error)
$(LI $(BUGZILLA 12673): ICE with static assert and __traits$(LPAREN)compiles$(RPAREN) with non-existent symbol)
$(LI $(BUGZILLA 12677): Assertion failure: 'isCtfeValueValid$(LPAREN)newval$(RPAREN)' on line 6579 in file 'interpret.c')
$(LI $(BUGZILLA 12678): Field constness missing in diagnostics for multiple field initialization error)
$(LI $(BUGZILLA 12686): Struct invariant prevents NRVO)
$(LI $(BUGZILLA 12688): Strange error if function call is in parentheses)
$(LI $(BUGZILLA 12704): typeof function literal incorrectly infers attributes)
$(LI $(BUGZILLA 12705): @system is missing when using getFunctionAttributes on a typeof$(LPAREN)function$(RPAREN))
$(LI $(BUGZILLA 12706): ddoc: __dollar should not appear in the documentation)
$(LI $(BUGZILLA 12725): IFTI should consider instantiated types with dependent template parameters)
$(LI $(BUGZILLA 12737): static constructor requires call of super constructor)
$(LI $(BUGZILLA 12739): Foreach delegate to opApply does not have infered nothrow)
$(LI $(BUGZILLA 12745): [Ddoc] Underscore is removed from numbers in document comments)
$(LI $(BUGZILLA 12746): Wrong overload access within manually aliased eponymous function template)
$(LI $(BUGZILLA 12749): Constructor-local function allows multiple mutation of immutable member)
$(LI $(BUGZILLA 12756): Cannot build dmd on windows because of longdouble)
$(LI $(BUGZILLA 12777): const/immutable member function violating its const-ness - confusing error message)
$(LI $(BUGZILLA 12778): Aliasing opBinaryRight to opBinary works only in certain cases)
$(LI $(BUGZILLA 12788): -di doesn't warn about implicit conversion from char[] to char*)
$(LI $(BUGZILLA 12809): More strict nothrow check for try-finally statement)
$(LI $(BUGZILLA 12820): DMD can inline calls to functions that use alloca, allocating the memory in the caller function instead.)
$(LI $(BUGZILLA 12825): Invalid "duplicated union initialization" error with initialized field in extern$(LPAREN)C++$(RPAREN) class)
$(LI $(BUGZILLA 12826): Win64: bad code for x ~= x;)
$(LI $(BUGZILLA 12833): switch statement does not work properly when -inline used)
$(LI $(BUGZILLA 12836): CTFE ICE CompiledCtfeFunction::walkAllVars)
$(LI $(BUGZILLA 12838): Dmd show ICEs when using Tuple and wrong type)
$(LI $(BUGZILLA 12841): ICE on taking function address)
$(LI $(BUGZILLA 12849): pmovmskb instruction cannot store to 64-bit registers)
$(LI $(BUGZILLA 12850): ICE when passing associative array to template)
$(LI $(BUGZILLA 12851): ICE when passing const static array to template)
$(LI $(BUGZILLA 12852): 64 bit wrong code generated)
$(LI $(BUGZILLA 12855): Shadow register assignments for spilling can conflict)
$(LI $(BUGZILLA 12873): Valgrind unhandled instruction bytes 0x48 0xDB $(LPAREN)redundant REX_W prefix on x87 load$(RPAREN))
$(LI $(BUGZILLA 12874): Wrong file name in range violation error)
$(LI $(BUGZILLA 12876): Implicit cast of array slice to fixed-size array for templates too)
$(LI $(BUGZILLA 12901): `in`/`out` contracts on struct constructor must require function body)
$(LI $(BUGZILLA 12902): [ICE] Assertion failure '!ae->lengthVar' in 'expression.c' when using `opDollar`)
$(LI $(BUGZILLA 12907): [ICE] Assertion failure '0' in 'mangle.c' when using `auto` return type with lambda with dereferanced `function` call)
$(LI $(BUGZILLA 12909): [AA] Function is incorrectly inferred as strongly pure for associative array with key of non-mutable array or pointer as argument)
$(LI $(BUGZILLA 12928): Bounds check dropped for array[length])
$(LI $(BUGZILLA 12933): [D1] ICE with default __FILE__ and __LINE__)
$(LI $(BUGZILLA 12934): Strange newly implemented VRP behavior on foreach)
$(LI $(BUGZILLA 12937): ICE with void static array initializing)
$(LI $(BUGZILLA 12938): Error message mistake in out parameter with @disable this)
$(LI $(BUGZILLA 12953): Wrong alignment number in error messages)
$(LI $(BUGZILLA 12962): osver.mak should use isainfo on Solaris to determine model)
$(LI $(BUGZILLA 12965): DMD sets ELFOSABI to ELFOSABI_LINUX on all systems)
$(LI $(BUGZILLA 12968): DMD inline asm outputs wrong XCHG instruction)
$(LI $(BUGZILLA 12970): Enclosing @system attribute is precedence than postfix @safe)
$(LI $(BUGZILLA 13003): Lack of read-modify-write operation check on shared object field)
$(LI $(BUGZILLA 13011): inout delegate parameter cannot receive exactly same type argument)
$(LI $(BUGZILLA 13023): optimizer produces wrong code for comparision and division of ulong)
$(LI $(BUGZILLA 13043): Redundant linking to TypeInfo in non-root module)
$(LI $(BUGZILLA 13044): Assignment of structs with const members)
$(LI $(BUGZILLA 13045): TypeInfo.getHash should return consistent result with object equality by default)
$(LI $(BUGZILLA 13049): in template arguments the compiler fails to parse scope for function pointers arguments)
$(LI $(BUGZILLA 13050): pragma mangle breaks homonym template aliasing)
$(LI $(BUGZILLA 13082): Spurious error message with failed call to class ctor)
$(LI $(BUGZILLA 13088): Compiler segfaults with trivial case code.)
$(LI $(BUGZILLA 13089): Spurious 'is not nothrow' error on static array initialization)
$(LI $(BUGZILLA 13109): -run and -lib dmd flags conflict)
$(LI $(BUGZILLA 13116): Should not be able to return ref to 'this')
$(LI $(BUGZILLA 13131): [2.066-b3] dmd: glue.c:1492: unsigned int totym$(LPAREN)Type*$(RPAREN): Assertion `0` failed.)
$(LI $(BUGZILLA 13135): IFTI fails on partially qualified argument in some cases)
$(LI $(BUGZILLA 13142): Enums on different classes confuse the compiler)
$(LI $(BUGZILLA 13161): Wrong offset of extern$(LPAREN)C++$(RPAREN) class member)
$(LI $(BUGZILLA 13175): [D1] ICE on conflicting overloads in presense of default __FILE__/__LINE__)
$(LI $(BUGZILLA 13182): extern$(LPAREN)C++$(RPAREN) classes cause crash when allocated on the stack with scope)
$(LI $(BUGZILLA 13190): Optimizer breaks comparison with zero)
$(LI $(BUGZILLA 13194): ICE when static class members initialized to void)
$(LI $(BUGZILLA 13195): Delete calls destructor but doesn't free)
$(LI $(BUGZILLA 13204): recursive alias declaration)
$(LI $(BUGZILLA 13212): Trailing Windows line endings not stripped from .ddoc macros)
$(LI $(BUGZILLA 13217): nothrow, template function and delegate: compilation error)
$(LI $(BUGZILLA 13225): [ICE] Access violation on invalid mixin template instantiation)
$(LI $(BUGZILLA 13226): Symbol is not accessible when using traits or mixin)
$(LI $(BUGZILLA 13230): std.variant.Variant Uses Deprecated .min Property in opArithmetic When T is a Floating Point Type)
$(LI $(BUGZILLA 13235): Wrong code on mutually recursive tuple type)
$(LI $(BUGZILLA 13260): [D1] ICE accessing non-existent aggregate member)
$(LI $(BUGZILLA 13273): ddoc can't handle \r in unittests and ESCAPES properly)
$(LI $(BUGZILLA 13275): Wrong di header generation on if and foreach statements)
)
)
$(BUGSTITLE DMD Compiler enhancements,

$(P
$(LI $(BUGZILLA 1553): foreach_reverse is allowed for delegates)
$(LI $(BUGZILLA 1673): Implement the isTemplate trait)
$(LI $(BUGZILLA 1952): Support a unit test handler)
$(LI $(BUGZILLA 2025): Inconsistent rules for instantiating templates with a tuple parameter)
$(LI $(BUGZILLA 2548): Array ops that return value to a new array should work.)
$(LI $(BUGZILLA 3882): Unused result of pure functions)
$(LI $(BUGZILLA 5070): Heap-allocated closures listing)
$(LI $(BUGZILLA 6798): Integrate overloadings for multidimentional indexing and slicing)
$(LI $(BUGZILLA 7747): Diagnostic should be informative for an inferred return type in a recursive call)
$(LI $(BUGZILLA 7961): Add support for C++ namespaces)
$(LI $(BUGZILLA 8101): Display candidate function overloads when function call fails)
$(LI $(BUGZILLA 9112): Uniform construction for built-in types)
$(LI $(BUGZILLA 9570): Wrong foreach index implicit conversion error)
$(LI $(BUGZILLA 9616): SortedRange should support all range kinds)
$(LI $(BUGZILLA 10018): Value range propagation for immutable variables)
$(LI $(BUGZILLA 11345): Optimize array literal to static array assignment to not allocate on GC heap)
$(LI $(BUGZILLA 11620): dmd json output should output enum values)
$(LI $(BUGZILLA 11819): Implement better diagnostics for unrecognized traits)
$(LI $(BUGZILLA 12232): The result of pointer arithmetic on unique pointers should be a unique pointer)
$(LI $(BUGZILLA 12273): 'dmd -color' flag to colorize error/warning messages)
$(LI $(BUGZILLA 12280): Redundant "template instance ... error instantiating" messages)
$(LI $(BUGZILLA 12290): IFTI should consider implicit conversions of the literal arguments)
$(LI $(BUGZILLA 12310): [CTFE] Support heap allocation for built-in scalar types)
$(LI $(BUGZILLA 12352): Consistently stop encoding return type of parent functions)
$(LI $(BUGZILLA 12550): Deprecate -noboundscheck and replace with more useful -boundscheck= option)
$(LI $(BUGZILLA 12598): Poor diagnostic with local import hijacking)
$(LI $(BUGZILLA 12606): Mismatch of known array length during dynamic => static array assignment should emit better diagnostics)
$(LI $(BUGZILLA 12641): D1: __FILE__ and __LINE__ default argument behaviour)
$(LI $(BUGZILLA 12653): Add the getFunctionAttributes trait)
$(LI $(BUGZILLA 12681): Rewrite rule prevents unique detection)
$(LI $(BUGZILLA 12798): constant folding should optimize subsequent concatenations)
$(LI $(BUGZILLA 12802): Allow optional 'StorageClasses' for new alias syntax)
$(LI $(BUGZILLA 12821): Missed redundant storage class / protection errors.)
$(LI $(BUGZILLA 12932): Support @nogc for immediately iterated array literal)
$(LI $(BUGZILLA 12967): Prefix method 'this' qualifiers should be disallowed in DeclDefs scope)
$(LI $(BUGZILLA 13001): Support VRP for ternary operator $(LPAREN)CondExp$(RPAREN))
$(LI $(BUGZILLA 13138): add peek/poke as compiler intrinsics)
$(LI $(BUGZILLA 13277): The base class in the JSON output is always unqualified)
$(LI $(BUGZILLA 13281): Print type suffix of real/complex literals in pragma$(LPAREN)msg$(RPAREN) and error diagnostic)
)
)
$(BUGSTITLE Phobos regressions,

$(P
$(LI $(BUGZILLA 12332): std.json API broken without notice)
$(LI $(BUGZILLA 12375): Writeln of a char plus a fixed size array of chars)
$(LI $(BUGZILLA 12394): Regression: std.regex unittests take agonizingly long to run - like hours on OSX)
$(LI $(BUGZILLA 12428): Regression $(LPAREN)2.066 git-head$(RPAREN): toUpper is corrupting input data $(LPAREN)modifying immutable strings$(RPAREN))
$(LI $(BUGZILLA 12455): [uni][reg] Bad lowercase mapping for 'LATIN CAPITAL LETTER I WITH DOT ABOVE')
$(LI $(BUGZILLA 12494): Regression $(LPAREN)2.064$(RPAREN): to!string$(LPAREN)enum$(RPAREN) returns incorrect value)
$(LI $(BUGZILLA 12505): Null pointers are pretty-printed even when hex output is requested)
$(LI $(BUGZILLA 12713): [REG 2.066A] std.regex.regex crashes with SEGV, illegal instruction resp. assertion failure with certain bad input)
$(LI $(BUGZILLA 12859): Read-modify-write operation for shared variable in Phobos)
$(LI $(BUGZILLA 13076): [dmd 2.066-b2] DList clearing of empty list)
$(LI $(BUGZILLA 13098): std.path functions no longer works with DirEntry)
$(LI $(BUGZILLA 13181): install target broken)
)
)
$(BUGSTITLE Phobos bugs,

$(P
$(LI $(BUGZILLA 1452): std.cstream doc incorrect - imports of stream and stdio are not public)
$(LI $(BUGZILLA 1726): std.stream FileMode documentation problems)
$(LI $(BUGZILLA 3054): multithreading GC problem. And Stdio not multithreading safe)
$(LI $(BUGZILLA 3363): std.stream.readf segfaults with immutable format strings)
$(LI $(BUGZILLA 3484): std.socket.Address hierarchy not const-safe)
$(LI $(BUGZILLA 4330): std.range.transposed$(LPAREN)$(RPAREN) should be documented)
$(LI $(BUGZILLA 4600): writeln$(LPAREN)$(RPAREN) is not thread-safe)
$(LI $(BUGZILLA 5177): std.socketstream's close$(LPAREN)$(RPAREN) should call super.close$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 5538): Immutable classes can't be passed as messages in std.concurrency)
$(LI $(BUGZILLA 5870): Debug code in SortedRange assumes it can always print the range)
$(LI $(BUGZILLA 6644): std.stdio write/writef$(LPAREN)ln$(RPAREN) are not @trusted)
$(LI $(BUGZILLA 6791): std.algorithm.splitter random indexes utf strings)
$(LI $(BUGZILLA 6998): std.container.Array destroys class instances)
$(LI $(BUGZILLA 7246): Provide a simpler example for std.algorithm.remove)
$(LI $(BUGZILLA 7289): Document how std.format handles structs, unions, and hashes.)
$(LI $(BUGZILLA 7693): Getopt Ignores Trailing Characters on Enums)
$(LI $(BUGZILLA 7767): Unstable sort - slow performance cases)
$(LI $(BUGZILLA 7822): lseek cast$(LPAREN)int$(RPAREN)offset  should be lseek  cast$(LPAREN)off_t$(RPAREN)offset)
$(LI $(BUGZILLA 7924): reduce does not work with immutable/const as map and filter do)
$(LI $(BUGZILLA 8086): std.stdio is underdocumented)
$(LI $(BUGZILLA 8590): Documentation for "any" and "all" in std.algorithm is incorrect)
$(LI $(BUGZILLA 8721): std.algorithm.remove problem)
$(LI $(BUGZILLA 8730): writeln stops on a nul character, even if passed a D string)
$(LI $(BUGZILLA 8756): Add link to location of curl static library)
$(LI $(BUGZILLA 8764): chunks.transposed causes infinite ranges.)
$(LI $(BUGZILLA 8866): Splitter$(LPAREN)R1, R2$(RPAREN) CANNOT be bidirectional.)
$(LI $(BUGZILLA 8905): DList.Range: Internal error, inconsistent state)
$(LI $(BUGZILLA 8921): Enum arrays should be formatted properly)
$(LI $(BUGZILLA 9015): std.container.DList.opOpAssign missing return)
$(LI $(BUGZILLA 9016): swap$(LPAREN)$(RPAREN) doesn't work with std.container.DList.front and back)
$(LI $(BUGZILLA 9054): std.net.curl byLineAsync and byChunkAsync broken.)
$(LI $(BUGZILLA 9556): Missing underscore in docs for std.string.isNumeric)
$(LI $(BUGZILLA 9878): std.algorithm.cartesianProduct results order)
$(LI $(BUGZILLA 9975): pointsTo asserts because of false pointer in union)
$(LI $(BUGZILLA 10500): Problem with length property when using variant)
$(LI $(BUGZILLA 10502): Can't get fullyQualifiedName of a templated struct)
$(LI $(BUGZILLA 10693): cartesianProduct with over 7 ranges causes segfault at compile time)
$(LI $(BUGZILLA 10779): cartesianProduct leads to heavy code bloat)
$(LI $(BUGZILLA 10798): std.regex: ctRegex unicode set ops unimplemented)
$(LI $(BUGZILLA 10911): std.net.curl.HTTP: should allow user code to indicate content type of POST data)
$(LI $(BUGZILLA 10916): toHash on VariantN not being recognised)
$(LI $(BUGZILLA 10931): etc.c.zlib should properly annotate const parameters)
$(LI $(BUGZILLA 10948): BitArray.opEquals is invalid)
$(LI $(BUGZILLA 11017): std.string/uni.toLower is very slow)
$(LI $(BUGZILLA 11072): BitArray.opCmp is invalid on 64x)
$(LI $(BUGZILLA 11175): Format should support IUnknown classes)
$(LI $(BUGZILLA 11183): Win64: lrint yields bad results)
$(LI $(BUGZILLA 11184): Win64: killing process with invalid handle terimates current process)
$(LI $(BUGZILLA 11192): std.demangle doesn't demangle alias template arguments)
$(LI $(BUGZILLA 11253): std.algorithm.count is not nothrow)
$(LI $(BUGZILLA 11308): Don't use Voldemort types for std.process output)
$(LI $(BUGZILLA 11364): Variant fails to compile with const$(LPAREN)TypeInfo$(RPAREN).)
$(LI $(BUGZILLA 11608): Inadequate documentation for std.getopt.config.passThrough)
$(LI $(BUGZILLA 11698): readf doesn't compile with bool)
$(LI $(BUGZILLA 11705): std.typecons.Typedef is missing proper documentation)
$(LI $(BUGZILLA 11778): format for null does not verify fmt flags.)
$(LI $(BUGZILLA 11784): std.regex: bug in set intersection)
$(LI $(BUGZILLA 11825): An impossible memcpy at CTFE with cartesianProduct.array)
$(LI $(BUGZILLA 11834): std.net.curl: ddoc warnings)
$(LI $(BUGZILLA 11978): std.algorithm canFind uses "value" where it means "needle")
$(LI $(BUGZILLA 12007): cartesianProduct doesn't work with ranges of immutables)
$(LI $(BUGZILLA 12076): ctRegex range violation)
$(LI $(BUGZILLA 12148): std.uuid.parseUUID should document that it changes lvalue input data)
$(LI $(BUGZILLA 12157): Variant opEquals always returns false for classes.)
$(LI $(BUGZILLA 12169): sum$(LPAREN)int[]$(RPAREN) should return a int)
$(LI $(BUGZILLA 12183): using std.algorithm.sort makes valgrind abort)
$(LI $(BUGZILLA 12245): BinaryHeap exhibits quadratic performance in debug mode)
$(LI $(BUGZILLA 12297): std.typecons.Proxy does not properly forward IFTI calls)
$(LI $(BUGZILLA 12309): The template fullyQualifiedName returns wrong result)
$(LI $(BUGZILLA 12349): std.File.flush and error causes segfault after calling close)
$(LI $(BUGZILLA 12356): std.traits.isTypeTuple and isExpressionTuple are poorly documented)
$(LI $(BUGZILLA 12366): Range violation in compile-time regex)
$(LI $(BUGZILLA 12419): assertion failure in std.utf)
$(LI $(BUGZILLA 12434): std.algorithm.sum of immutable array too)
$(LI $(BUGZILLA 12449): Undefined format in std.algorithm.max)
$(LI $(BUGZILLA 12464): DMD/Phobos cannot auto-implement D variadic methods)
$(LI $(BUGZILLA 12477): std.bitmanip should emit informative diagnostics)
$(LI $(BUGZILLA 12557): std.numeric.gcd documentation reports Euler's algorithm, but it uses Euclid's algorithm)
$(LI $(BUGZILLA 12568): std.functional.memoize with constant array argument too)
$(LI $(BUGZILLA 12569): Better error message for std.algorithm.reduce used with two functions and a scalar seed)
$(LI $(BUGZILLA 12582): Non-existant named capture groups cause runtime range violation or segmentation fault in regex)
$(LI $(BUGZILLA 12600): Variant should support coercion to bool)
$(LI $(BUGZILLA 12608): Dead assignment in UUIDParsingException)
$(LI $(BUGZILLA 12609): Useless variable assignment in std.regex)
$(LI $(BUGZILLA 12643): @nogc std.range.dropOne)
$(LI $(BUGZILLA 12668): std.traits.functionAttributes should use the new getFunctionAttributes trait)
$(LI $(BUGZILLA 12691): std.regex.bmatch bug in empty OR operator inside of $(LPAREN)$(RPAREN)*)
$(LI $(BUGZILLA 12731): Infinite range slices are not themselves sliceable)
$(LI $(BUGZILLA 12747): std.regex bug in the parser allows reference to open groups.)
$(LI $(BUGZILLA 12771): opIndex on static arrays in a Variant is not implemented.)
$(LI $(BUGZILLA 12781): process.d: "Executable file not found" is supposed to show executable name but fails)
$(LI $(BUGZILLA 12796): std.string toLower/toUpper array conversion.)
$(LI $(BUGZILLA 12806): Does std.traits.isArray include associative arrays?)
$(LI $(BUGZILLA 12828): Fix SimpleTimeZone.utcOffset so that it has the correct return type)
$(LI $(BUGZILLA 12846): Phobos git HEAD: std.datetime spewing out tons of deprecation messages)
$(LI $(BUGZILLA 12853): std.encoding EncodingSchemeUtf16Native and EncodingSchemeUtf32Native decode$(LPAREN)$(RPAREN) and SafeDecode$(LPAREN)$(RPAREN) wrong stripping length)
$(LI $(BUGZILLA 12875): [unittest] std.datetime fails: Not a valid tzdata file.)
$(LI $(BUGZILLA 12898): `std.process.browse` expects URL to be encoded in CP_ACP on Windows instead of UTF-8)
$(LI $(BUGZILLA 12921): Module std.getopt does not respect property syntax)
$(LI $(BUGZILLA 12923): UTF exception in stride even though passes validate.)
$(LI $(BUGZILLA 12996): SList: linearRemove cannot remove root node)
$(LI $(BUGZILLA 13000): Casts should be removed to utilize features of inout)
$(LI $(BUGZILLA 13068): std.typecons.Unique should disable postblit)
$(LI $(BUGZILLA 13100): std.process.setCLOEXEC$(LPAREN)$(RPAREN) throws on invalid file descriptor)
$(LI $(BUGZILLA 13151): std.range.take template constraint ambiguity)
$(LI $(BUGZILLA 13163): std.conv.parse misses overflow when it doesn't result in a smaller value)
$(LI $(BUGZILLA 13171): std.algorithm.until$(LPAREN)range, sentinel, OpenRight.no$(RPAREN) doesn't propagate popping of sentinel to range)
$(LI $(BUGZILLA 13214): array.opSlice one element falsy empty)
$(LI $(BUGZILLA 13258): std.process file closing logic is incorrect)
$(LI $(BUGZILLA 13263): phobos/posix.mak has incorrect dependencies)
)
)
$(BUGSTITLE Phobos enhancements,

$(P
$(LI $(BUGZILLA 3780): getopt improvements by Igor Lesik)
$(LI $(BUGZILLA 4725): std.algorithm.sum$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 4999): Add Kenji Hara's adaptTo$(LPAREN)$(RPAREN) to Phobos)
$(LI $(BUGZILLA 5175): Add a way to get parameter names to std.traits)
$(LI $(BUGZILLA 5228): Add GetOptException $(LPAREN)or similar$(RPAREN) to std.getopt)
$(LI $(BUGZILLA 5240): Faster std.random.uniform$(LPAREN)$(RPAREN) for [0.0, 1.0$(RPAREN) range)
$(LI $(BUGZILLA 5316): std.getopt: Add character-separated elements support for arrays and associative arrays)
$(LI $(BUGZILLA 5808): std.string.indexOf enhancement with start-at parameter)
$(LI $(BUGZILLA 6793): Document that assumeUnique may not be necessary in some contexts)
$(LI $(BUGZILLA 7146): enhance strip* $(LPAREN)implementation provided$(RPAREN))
$(LI $(BUGZILLA 8278): std.range.chunks for generic Forward Ranges?)
$(LI $(BUGZILLA 8762): instanceOf trait for static conditionals)
$(LI $(BUGZILLA 9819): Allow access to named tuple's names.)
$(LI $(BUGZILLA 9942): Add a functional switch function)
$(LI $(BUGZILLA 10162): Opposite of std.string.representation)
$(LI $(BUGZILLA 11598): std.random.uniform could be faster for integrals)
$(LI $(BUGZILLA 11876): std.getopt: Implement --help and --help=option automatic printout)
$(LI $(BUGZILLA 12015): std.digest.sha256 too)
$(LI $(BUGZILLA 12027): Range of true bits for std.bitmanip.BitArray)
$(LI $(BUGZILLA 12173): Optional start value for std.algorithm.sum)
$(LI $(BUGZILLA 12184): Provide formating options for std.uni.InversionList)
$(LI $(BUGZILLA 12446): std.parallelism.amap prefer iteration to indexing)
$(LI $(BUGZILLA 12448): "in" argument for std.string.toStringz)
$(LI $(BUGZILLA 12479): replace "pointsTo" with "maybePointsTo" and "definitlyPointsTo")
$(LI $(BUGZILLA 12556): Add persistent byLine)
$(LI $(BUGZILLA 12566): Give DList true reference semantics)
$(LI $(BUGZILLA 12596): Implement Typedef ctor that can take itself as a parameter)
$(LI $(BUGZILLA 12633): std.conv.to should support target fixed-sized arrays)
$(LI $(BUGZILLA 12644): Some std.math functions are not yet @nogc)
$(LI $(BUGZILLA 12656): Some functions in std.ascii can be @nogc)
$(LI $(BUGZILLA 12671): std.complex abs and ^^ @nogc)
$(LI $(BUGZILLA 12784): Add an "in" operator for std.json.JSONValue)
$(LI $(BUGZILLA 12835): std.random.uniform with open lower bound cannot support smaller integral types or character types)
$(LI $(BUGZILLA 12877): std.random.uniform cannot handle dchar variates)
$(LI $(BUGZILLA 12886): std.datetime cannot parse HTTP date)
$(LI $(BUGZILLA 12890): std.array index based replace)
$(LI $(BUGZILLA 12957): std.algorithm.cartesianProduct is sometimes very slow to compile)
$(LI $(BUGZILLA 13013): Failed unittests in std.json - does not parse doubles correctly)
$(LI $(BUGZILLA 13022): std.complex lacks a function returning the squared modulus of a Complex)
$(LI $(BUGZILLA 13042): std.net.curl.SMTP doesn't send emails with libcurl-7.34.0 or newer)
$(LI $(BUGZILLA 13159): std.socket.getAddress allocates once per DNS lookup hit)
)
)
$(BUGSTITLE Druntime regressions,

$(P
$(LI $(BUGZILLA 12220): [REG2.066a] hash.get$(LPAREN)$(RPAREN) does not accept proper parameters)
$(LI $(BUGZILLA 12427): Regression $(LPAREN)2.066 git-head$(RPAREN): Building druntime fails with -debug=PRINTF)
$(LI $(BUGZILLA 12710): Bad @nogc requirement for Windows callbacks)
$(LI $(BUGZILLA 12738): core.sys.posix.signal sigaction_t handler type mismatch)
$(LI $(BUGZILLA 12848): [REG2.061] crash in _d_run_main$(LPAREN)$(RPAREN) on some unicode command line argument $(LPAREN)Win32$(RPAREN))
$(LI $(BUGZILLA 13078): [dmd 2.066-b2] AA rehash failed with shared)
$(LI $(BUGZILLA 13084): ModuleInfo.opApply delegate expects immutable parameter)
$(LI $(BUGZILLA 13111): GC.realloc returns invalid memory for large reallocation)
$(LI $(BUGZILLA 13148): ModuleInfo fields are unnecessary changed to const)
)
)
$(BUGSTITLE Druntime bugs,

$(P
$(LI $(BUGZILLA 4323): std.demangle incorrectly handles template floating point numbers)
$(LI $(BUGZILLA 5892): Lazy evaluation of stack trace when exception is thrown)
$(LI $(BUGZILLA 7954): x86_64 Windows fibers do not save nonvolatile XMM registers)
$(LI $(BUGZILLA 8607): __simd and pcmpeq should be @safe pure nothrow)
$(LI $(BUGZILLA 9584): Exceptions in D are ludicrously slow $(LPAREN)far worse than Java$(RPAREN))
$(LI $(BUGZILLA 10380): [AA] Wrong code using associative array as key type in associative array)
$(LI $(BUGZILLA 10897): btc, btr and bts shouldn't be safe)
$(LI $(BUGZILLA 11011): core.time.Duration has example code which cannot compile)
$(LI $(BUGZILLA 11037): [AA] AA's totally broken for struct keys with indirection)
$(LI $(BUGZILLA 11519): fix timing issue in core.thread unittest)
$(LI $(BUGZILLA 11761): aa.byKey and aa.byValue are not forward ranges)
$(LI $(BUGZILLA 12800): Fibers are broken on Win64)
$(LI $(BUGZILLA 12870): No x86_64 optimized implementation for float array ops)
$(LI $(BUGZILLA 12958): core.checkedint.mulu is broken)
$(LI $(BUGZILLA 12975): posix.mak should use isainfo on Solaris systems to determine model)
$(LI $(BUGZILLA 13057): posix getopt variables in core/sys/posix/unistd.d should be marked __gshared)
$(LI $(BUGZILLA 13073): Wrong uint/int array comparison)
)
)
$(BUGSTITLE Druntime enhancements,

$(P
$(LI $(BUGZILLA 8409): Proposal: implement arr.dup in library)
$(LI $(BUGZILLA 12964): dev_t is incorrectly defined in runtime for Solaris systems)
$(LI $(BUGZILLA 12976): ModuleInfo should be immutable on Solaris)
$(LI $(BUGZILLA 12977): lf64 definitions aren't correct on Solaris)
$(LI $(BUGZILLA 12978): struct sigaction is too small on 32-bit solaris)
$(LI $(BUGZILLA 13037): SIGRTMIN and SIGRTMAX aren't correctly defined on Solaris)
$(LI $(BUGZILLA 13144): Add fenv support for Solaris)
$(LI $(BUGZILLA 13145): Need LC_ locale values for Solaris)
$(LI $(BUGZILLA 13146): Add missing function definitions from stdlib.h on Solaris)
)
)
$(BUGSTITLE Installer regressions,

$(P
$(LI $(BUGZILLA 13004): /? option to cl.exe results in ICE)
$(LI $(BUGZILLA 13047): cannot stat `./icons/16/dmd-source.png`: No such file or directory)
$(LI $(BUGZILLA 13210): libphobos2.so not being built)
$(LI $(BUGZILLA 13233): Windows installer: downloading external installers $(LPAREN)Visual D/dmc$(RPAREN) does not work)
)
)
$(BUGSTITLE Installer bugs,

$(P
$(LI $(BUGZILLA 3319): DInstaller overwrites the %PATH% variable)
$(LI $(BUGZILLA 5732): Windows installer creates incorrect target for Start menu link)
$(LI $(BUGZILLA 13149): released libphobos2.a is build with PIC code)
)
)
$(BUGSTITLE Website regressions,

$(P
$(LI $(BUGZILLA 12813): Parser is confused between float and UFC syntax)
)
)
$(BUGSTITLE Website bugs,

$(P
$(LI $(BUGZILLA 1497): Add a link to the DWiki debuggers page)
$(LI $(BUGZILLA 1574): DDoc documentation lacks macro examples)
$(LI $(BUGZILLA 3093): Object.factory has incomplete documentation)
$(LI $(BUGZILLA 4164): sieve Sample D Program -- need documentation for array representation)
$(LI $(BUGZILLA 6017): std.algorithm.remove has a wrong link)
$(LI $(BUGZILLA 7075): overloading opAssign for classes is poorly specified)
$(LI $(BUGZILLA 7459): Document the workarounds for mutually-called nested functions.)
$(LI $(BUGZILLA 8074): template-mixin example contradicts text)
$(LI $(BUGZILLA 8798): Tuple curry example not really curry)
$(LI $(BUGZILLA 9542): Broken link on std.range doc page)
$(LI $(BUGZILLA 10033): Wrong example in chapter Vector Extensions)
$(LI $(BUGZILLA 10231): Spec: Document typed alias parameter feature)
$(LI $(BUGZILLA 10297): Memory safe D spec is out of date)
$(LI $(BUGZILLA 10564): Errors on the Template page of the language specification)
$(LI $(BUGZILLA 10764): bug reporting / better linking to issue tracker / include resolved in default search)
$(LI $(BUGZILLA 10901): Win_64 Autotester KO'd)
$(LI $(BUGZILLA 11104): Document exact behavior of structsasd initialization inside AA)
$(LI $(BUGZILLA 11396): Function alias declaration not valid according to spec)
$(LI $(BUGZILLA 11462): std.algorithm.multiSort is missing from the index)
$(LI $(BUGZILLA 11638): Variadic function documentation, out-of-date example)
$(LI $(BUGZILLA 11846): Missing pragma/$(LPAREN)mangle$(RPAREN) documentation)
$(LI $(BUGZILLA 11867): Documentation for new package.d feature)
$(LI $(BUGZILLA 11917): Stale Phobos documentation pages found on site root)
$(LI $(BUGZILLA 11979): inout const is not documented)
$(LI $(BUGZILLA 12005): DDoc example refers to a dead project, yet a more recent one exists that is not mentioned.)
$(LI $(BUGZILLA 12241): Document change to static opCall in changelog)
$(LI $(BUGZILLA 12293): forward is missing from std.algorithm's cheat-sheet)
$(LI $(BUGZILLA 12459): Bugzilla logs users in only on https site, and does not redirect from http to https)
$(LI $(BUGZILLA 12526): DDox possible issue with case sensitive file names)
$(LI $(BUGZILLA 12535): The language introduction page is not linked from index)
$(LI $(BUGZILLA 12538): ZeroBUGS links are broken)
$(LI $(BUGZILLA 12607): Document that IUnknown classes must mark toString with extern$(LPAREN)D$(RPAREN) when overriding it)
$(LI $(BUGZILLA 12623): Special lexing case not mentioned in language spec)
$(LI $(BUGZILLA 12740): DMD accepts invalid version syntax)
$(LI $(BUGZILLA 13012): Open bugs chart is missing from http://dlang.org/bugstats.php)
)
)
$(BUGSTITLE Website enhancements,

$(P
$(LI $(BUGZILLA 8103): Use case-insensitive sorting for Jump-to lists in the documentation)
$(LI $(BUGZILLA 12783): Adding 'Third Party Libraries' link to the navigation sidebar)
$(LI $(BUGZILLA 12858): Document opEquals usage in AAs)
)
)

)

$(VERSION 065, February 24, 2014, =================================================,

$(BUGSTITLE Compiler Changes,
$(LI $(RELATIVE_LINK2 d-scripts, Extensionless D source file names can now be run when using the -run switch.))
)

$(BUGSTITLE Language Changes,
$(LI $(RELATIVE_LINK2 disable-goto-skips-init, Goto jumps now cannot skip variable declarations.))
$(LI $(RELATIVE_LINK2 attribinference2, All instantiated functions now infer their attributes.))
$(LI $(RELATIVE_LINK2 inout-const, Add a new type qualifier $(D inout const).))
$(LI $(RELATIVE_LINK2 slicing-tuple, Entire slicing operation of built-in tuple is now accepted.))
$(LI $(RELATIVE_LINK2 untyped-packages, Packages and module names now have no type.))
$(LI $(RELATIVE_LINK2 staticfields2, Const and immutable fields with initializers are now deprecated.))
$(LI $(RELATIVE_LINK2 deprecate-unorderd-compares, Deprecate unordered floating point comparisons.))
$(LI $(RELATIVE_LINK2 deprecate-floating-properties, Deprecate $(D .min) property for floating-point types.))
$(LI $(RELATIVE_LINK2 ctfe-overlapped-field, CTFE can handle overlapped union fields.))
$(LI $(RELATIVE_LINK2 get-alias-this, Add a new trait getAliasThis.))
$(LI $(RELATIVE_LINK2 mixing-struct-opcall, Mixing struct constructors and static opCall is no longer allowed.))
)

$(BUGSTITLE Library Changes,
$(LI $(RELATIVE_LINK2 algorithm-pred, Many functions in std.algorithm can now be used as predicates to other functions.))
$(LI $(RELATIVE_LINK2 algorithm-all, Allow std.algorithm.all to be used without a predicate.))
$(LI $(RELATIVE_LINK2 uni-bygrapheme, Add std.uni.byGrapheme and std.uni.byCodePoint.))
$(LI $(RELATIVE_LINK2 range-only, Add support for any number of arguments to std.range.only.))
)

$(BUGSTITLE Linker Changes,
$(LI $(RELATIVE_LINK2 large-address-aware, Added /LARGEADDRESSAWARE to the Win32 Optlink linker.))
)

$(BR)$(BIG $(RELATIVE_LINK2 list2065, List of all bug fixes and enhancements in D 2.065.))

$(HR)

$(BUGSTITLE Compiler Changes,

$(LI $(LEGACY_LNAME2 d_scripts, d-scripts, Extensionless D source file names can now be run when using the -run switch:)

    $(P On Posix systems it is frequently useful to have a shebang line at the start of an extensionless file,
        which marks the tool used to compile the script. It's now possible to use this technique with D, e.g.
        the following is a D source file with the file name $(B "my-script"):

        ---------
        #!rdmd

        void main()
        {
        }
        ---------
    )

    $(P $(B Note:) This does not allow an arbitrary extension, as D source files need to be proper D identifiers.)
    $(P $(B Note:) This feature is not available on Windows, as Windows does not have extensionless executable files.)
    $(P $(B Note:) When compiling, and in order to avoid the default behavior of generating
        an extensionless executable
        which would overwrite the source file, the compiler will generate $(I "a.out") instead.
    )
)

)

$(BUGSTITLE Language Changes,

$(LI $(LEGACY_LNAME2 disable_goto_skips_init, disable-goto-skips-init, Goto jumps now cannot skip variable declarations:)

    $(P For a very long period, the following code had been allowed by mistake, but it is prohibited now:

        ---------
        import std.stdio;

        void main()
        {
            goto Label; // Error: goto skips declaration of variable v

            int v = 42;

        Label:
            writeln(v);
        }
        ---------
    )
)

$(LI $(LNAME2 attribinference2, All instantiated functions now infer their attributes:)

    $(P Regardless of how directly or indirectly a function is instantiated, its attributes will still be inferred:

        ---------
        struct S(T)
        {
            T square(T x)
            {
                T calc()
                {
                    return x * x;
                }
                return calc();
            }

            static double pi() { return 3.141592; }
        }

        void main() pure @safe nothrow
        {
            S!int s;

            // S!int.square and its nested function calc are instantiated functions, so
            // their attributes are inferred as pure and callable from main()
            assert(s.square(2) == 4);  // ok

            // static member function attributes are also inferred now
            auto pi = typeof(s).pi();
        }
        ---------
    )
)

$(LI $(LEGACY_LNAME2 inout_const, inout-const, Add a new type qualifier $(D inout const):)

    $(P Until now, the common type of $(D immutable$(LPAREN)T$(RPAREN)) and $(D inout$(LPAREN)T$(RPAREN)) had been
        $(D const$(LPAREN)T$(RPAREN)). But that loses the $(D inout) information, which might then refuse some valid code.
        Now the type becomes $(D inout$(LPAREN)const$(LPAREN)T$(RPAREN)$(RPAREN)), which meaningfully propagates the appropriate type qualifier.

        ---------
        inout(const(int))[] foo(bool condition, inout(int)[] x, immutable(int)[] y)
        {
            static assert(is(typeof(condition ? x : y) == inout(const(int))[]));
            return condition ? x : y;
        }

        void main()
        {
            int[] marr = [1,2,3];
            const(int)[] carr = [4,5,6];
            immutable(int)[] iarr = [7,8,9];

            // inout(const(int))[] can go back to const(int)[] or immutable(int)[].
            static assert(is(typeof(foo(true, marr, iarr)) == const(int)[]));
            static assert(is(typeof(foo(true, carr, iarr)) == const(int)[]));
            static assert(is(typeof(foo(true, iarr, iarr)) == immutable(int)[]));
        }
        ---------
    )
)

$(LI $(LEGACY_LNAME2 slicing_tuple, slicing-tuple, Entire slicing operation of built-in tuple is now accepted:)

    $(P $(BUGZILLA 8244): cannot slice a type tuple with '[]' in locations where a type is valid:

        ---------
        import std.typetuple;
        alias Types = TypeTuple!(int, double, string);

        // Was error in 2.064, but allowed from 2.065.
        alias Types2 = Types[];
        static assert(is(Types == Types2));
        ---------
    )
)

$(LI $(LEGACY_LNAME2 untyped_packages, untyped-packages, Packages and module names now have no type:)

    $(P $(BUGZILLA 9081): Modules shouldn't have a type

        ---------
        import std.stdio;

        // Both had printed 'void' in 2.064.
        // From 2.065, both will cause "has no type" error.
        pragma(msg, typeof(std));
        pragma(msg, typeof(std.stdio));
        ---------
    )

    $(P By the change, an idiom that used to work
        $(D is$(LPAREN)typeof$(LPAREN)package_or_module_name$(RPAREN)$(RPAREN))
        is changed to not work. Instead use: $(D __traits$(LPAREN)compiles, package_or_module_name$(RPAREN)).
    )
)

$(LI $(LNAME2 staticfields2, Const and immutable fields with initializers are now deprecated:)

    $(P Eventually, they will be changed to occupy space in the object. Such fields should now be changed to enum or static.
        See also $(RELATIVE_LINK2 staticfields, the release note in 2.063).
    )

    $(P Related to that, void-initialized const or immutable fields will now
        occupy space in the object instance ahead of schedule:

        ---------
        struct S
        {
            const int[1000] x = void;

            this(int n)
            {
                // Was disallowed in 2.064.
                // From 2.065 x is a field of runtime object.
                x[] = n;
            }
        }

        // S.sizeof had been 1 in 2.064.
        // From 2.065, field s.x occupies space in the object.
        static assert(S.sizeof == int.sizeof * 1000);

        void main()
        {
            S s = S(3);

            foreach (e; s.x)
            {
                assert(e == 3); // OK
            }
        }
        ---------
    )
)

$(LI $(LEGACY_LNAME2 deprecate_unorderd_compares, deprecate-unorderd-compares, Deprecate unordered floating point comparisons:)

    $(P $(BUGZILLA 10369): Deprecate unordered floating point comparisons
    )
)

$(LI $(LEGACY_LNAME2 deprecate_floating_properties, deprecate-floating-properties, Deprecate $(D .min) property for floating-point types:)

    $(P $(BUGZILLA 10439): Deprecate float.min, double.min, real.min
    )
)

$(LI $(LEGACY_LNAME2 ctfe_overlapped_field, ctfe-overlapped-field, CTFE can handle overlapped union fields:)

    $(P Example code:

        ---------
        union U
        {
            size_t x;
            int* y;
        }

        bool test()
        {
            U u;
            assert(u.x == 0);
            // In here, reading u.y will cause CTFE error.

            u.y = [1,2,3].ptr;
            // Writing value to overlapped field u.y will make corresponding field u.x invalid.

            assert(u.y[0..3] == [1,2,3]);
            // u.y holds valid field and reading it is allowed
            // In here, reading u.x will cause CTFE error.

            u.x = 10;
            // Set value to u.x again.
            assert(u.x == 10);  // OK
            // In here, reading u.y will cause CTFE error.

            return true;
        }
        static assert(test());  // run CTFE
        ---------
    )

    $(P Bit image reinterpretation by using two overlapped union fields is not allowed during CTFE.
    )
)

$(LI $(LEGACY_LNAME2 get_alias_this, get-alias-this, Add a new trait getAliasThis:)

    $(P The new $(B getAliasThis) trait will return a tuple of field names which are marked as the
        $(LINK2 class.html#AliasThis, subtypes) of an aggregate type. For example:

        ---------
        struct S
        {
            string var;
            alias var this;
        }

        static assert(__traits(getAliasThis, S)[0] == "var");
        ---------
    )

    $(P $(B Note:) Multiple subtyping is not yet implemented in D, therefore this trait will always
        return a tuple of length 1.
    )
)

$(LI $(LNAME2 mixing-struct-opcall, Mixing struct constructors and static opCall is no longer allowed):
    $(P This was not implemented correctly and caused ambiguities.)
    $(P
        Example:
        ---
        struct S
        {
            this(int i) {}

            static S opCall()   // disallowed due to constructor
            {
                return S.init;
            }
        }
        ---
    )
    $(P Note: $(D static opCall) can be used to simulate struct
    constructors with no arguments, but this is not recommended
    practice. Instead, the preferred solution is to use a factory
    function to create struct instances.
    )
)

)

$(BUGSTITLE Library Changes,

$(LI $(LEGACY_LNAME2 algorithm_pred, algorithm-pred, Many functions in std.algorithm can now be used as predicates to other functions:)

    $(P Functions such as $(XREF algorithm, any), $(XREF algorithm, all), $(XREF algorithm, canFind)
        and $(XREF algorithm, equal) are now templates, which allows them to be used as predicates to
        other templates, as well as allowing the user to alias an instantiation of any such templates.
        For an example of how this allows terser syntax in user-code, in the following example the
        programmer wants to check whether all the strings in a string array have at least one ASCII digit:

        ---------
        import std.algorithm : all;
        import std.ascii : isDigit;

        void main()
        {
            string[] inputs = ["foo1", "bar2"];

            bool allContainDigit;
            foreach (input; inputs)
            {
                if (!any!isDigit(input))  // none of the characters are ASCII digits
                {
                    allContainDigit = false;
                    break;
                }
            }
        }
        ---------
    )

    $(P But it is now simpler to use the $(D any) template itself as a predicate.
        We can make it a predicate to another useful template, the $(D all) template:

        ---------
        import std.algorithm : any, all;
        import std.ascii : isDigit;

        void main()
        {
            string[] inputs = ["foo1", "bar2"];
            bool allContainDigit = all!(any!isDigit)(inputs);
        }
        ---------
    )

    $(P In addition to allowing these functions to become predicates they can now also be aliased,
        which allow you to make your functions simpler to understand:

        ---------
        import std.algorithm : any, all;
        import std.ascii : isDigit;

        void main()
        {
            alias isAnyDigit = any!isDigit;  // less visual noise and a self-describing function

            string[] inputs = ["foo1", "bar2"];
            bool allContainDigit = all!isAnyDigit(inputs);  // easier to understand

            alias doAllContainDigits = all!isAnyDigit;  // or wrap the entire algorithm into one symbol!

            assert( doAllContainDigits(["1", "a 1", "b 2"]));  // self-describing code
            assert(!doAllContainDigits(["c", "a 1", "b 2"]));
        }
        ---------
    )

    $(P You can of course combine $(D all) and $(D any) in a number of combinations. For example,
        if you want to reverse the test and instead check whether $(B any) of the strings in the
        string array contain $(B all) digits, the code might look like the following:

        ---------
        import std.algorithm : any, all;
        import std.ascii : isDigit;

        void main()
        {
            alias areAllDigits = all!isDigit;

            alias areAnyIntegrals = any!areAllDigits;

            assert( areAnyIntegrals(["123", "456"]));
            assert( areAnyIntegrals(["abc", "123"]));  // "123" is a number
            assert(!areAnyIntegrals(["abc", "def123"])); // "def123" is not really a number
        }
        ---------
    )

    $(P If on the other hand you want to ensure that $(B all) strings in the string array contain
        $(B all) digits, the could might look like the following:

        ---------
        import std.algorithm : any, all;
        import std.ascii : isDigit;

        void main()
        {
            alias areAllDigits = all!isDigit;

            alias allStringsDigits = all!areAllDigits;

            assert( allStringsDigits(["123", "456"]));
            assert(!allStringsDigits(["abc", "123"]));  // "123" is a number, but "abc" is not
        }
        ---------
    )
)

$(LI $(LEGACY_LNAME2 algorithm_all, algorithm-all, Allow std.algorithm.all to be used without a predicate.)

    $(P You no longer need to pass a predicate if you want to match all items in a range which
        implicitly convert to $(D true):

        ---------
        import std.algorithm;

        void main()
        {
            auto arr1 = [true, true, true];
            assert( all(arr1));  // all values are true

            auto arr2 = [false, true, true];
            assert(!all(arr2));  // all values are not true

            auto arr3 = [1, 2, 3];
            assert( all(arr3));  // all values convert to true

            auto arr4 = [0, 2, 3];
            assert(!all(arr4));  // all values do not convert to true
        }
        ---------
    )
)

$(LI $(LEGACY_LNAME2 uni_bygrapheme, uni-bygrapheme, Add std.uni.byGrapheme and std.uni.byCodePoint.)

    $(P Complementary higher-order ranges which enable range operations on graphemes:
        ---------
        import std.array : array;
        import std.range : retro;
        import std.string : text;
        import std.uni : byCodePoint, byGrapheme;

        void main()
        {
            string s = "noe\u0308l"; // noël
            // reverse it and convert the result back to UTF-8
            string reverse = s.byGrapheme()
                .array() // Note: byGrapheme will support bidirectionality in the future
                .retro()
                .byCodePoint()
                .text();

            assert(reverse == "le\u0308on"); // lëon
        }
        ---------
        Note that $(D byGrapheme) will support bidirectionality in the future,
        obviating the need for $(D array) in the above example.
    )
)

$(LI $(LEGACY_LNAME2 range_only, range-only, Add support for any number of arguments to std.range.only.)

    $(P $(XREF range, only) can now be used with more than one argument:
        ---------
        import std.algorithm : joiner;
        import std.range : equal, only;

        void main()
        {
            assert(only("one", "two", "three").joiner(" ").equal("one two three"));
        }
        ---------
    )

    $(P Additionally, $(D only()) is now a way to get an empty range.)
)

)

$(BUGSTITLE Linker Changes,

$(LI $(LEGACY_LNAME2 large_address_aware, large-address-aware, Added /LARGEADDRESSAWARE to the Win32 Optlink linker.)

    $(P When using the default Optlink linker on win32 (for linking 32-bit object files and executables),
        the $(B /LARGEADDRESSAWARE) option tells the linker that the application can handle addresses
        larger than 2 gigabytes. This is equivalent to Visual C's
        $(LINK2 http://msdn.microsoft.com/en-us/library/wz223b1z.aspx, linker option) of the same name since
        this is an operating-system feature that is enabled by setting a specific flag in the executable.
    )
)

)

$(BR)$(BIG $(LNAME2 list2065, List of all bug fixes and enhancements in D 2.065:))

$(BUGSTITLE DMD Compiler regressions,

$(P
$(LI $(BUGZILLA 7782): [ICE] With wrong import syntax)
$(LI $(BUGZILLA 9107): Value Range Analysis with uint and byte)
$(LI $(BUGZILLA 9639): Recursive template instanciation segfault dmd)
$(LI $(BUGZILLA 11078): Diagnostic for wrong RHS in property assign of a property group should improve)
$(LI $(BUGZILLA 11321): Can't link _D6object15__T7reserveTyaZ7reserveFNaNbNeKAyamZm)
$(LI $(BUGZILLA 11441): DMD halts compilation at semantic3)
$(LI $(BUGZILLA 11447): Closure provide bogus values)
$(LI $(BUGZILLA 11472): REGRESSION$(LPAREN)2.064$(RPAREN): dmd segfaults on wrong code instead of giving error)
$(LI $(BUGZILLA 11487): dmd segfaults on writefln in nested template)
$(LI $(BUGZILLA 11504): [CTFE] JSONValue cannot make in CTFE)
$(LI $(BUGZILLA 11505): Bad error message: "opAssign [...] is annotated with @disable")
$(LI $(BUGZILLA 11508): [REG 2.064] Wrong code with -O on x86_64 for char comparisons)
$(LI $(BUGZILLA 11513): [REG 2.064] Assertion in module.c)
$(LI $(BUGZILLA 11525): REG$(LPAREN)2.065$(RPAREN): Error: 'a[] *= a[]' each element is not a scalar, it is a Complex!double)
$(LI $(BUGZILLA 11553): dmd segfault with recursive template)
$(LI $(BUGZILLA 11554): `is$(LPAREN)T == enum$(RPAREN);` produces an error if T is an enum defined with no members)
$(LI $(BUGZILLA 11563): Module dependency cycle causes unrelated template instantiations to fail)
$(LI $(BUGZILLA 11566): ICE with invalid array op)
$(LI $(BUGZILLA 11596): Internal error: backend/cgcs.c 351)
$(LI $(BUGZILLA 11610): Compiler core dumps on FreeBSD, compiles forever on Linux)
$(LI $(BUGZILLA 11614): Error: this for _expand_field_0 needs to be type Tuple not type Foo)
$(LI $(BUGZILLA 11626): [ICE] $(LPAREN)mtype.c line 9718$(RPAREN) With missing in ref type)
$(LI $(BUGZILLA 11659): false positive goto skips initialization of variable error $(LPAREN)skipping enum initialization$(RPAREN))
$(LI $(BUGZILLA 11718): [REG2.065a] Unintended mangled names conflict of nested template structs)
$(LI $(BUGZILLA 11723): Too many "integer overflow" errors)
$(LI $(BUGZILLA 11730): associative array with Nullable!SysTime values: Called `get` on null Nullable!SysTime.)
$(LI $(BUGZILLA 11751): [REG2.065a] Hex float exponents should be decimal)
$(LI $(BUGZILLA 11755): Operator $(LESS)$(GREATER)= and !$(LESS)$(GREATER)= with arrays make internal error in e2ir)
$(LI $(BUGZILLA 11767): doubly mixed-in struct "failed semantic analysis")
$(LI $(BUGZILLA 11776): [ICE] Assertion failure: 'tf->next == NULL' on line 119 in file 'mangle.c')
$(LI $(BUGZILLA 11777): [ICE] dmd memory corruption as `Scope::pop` `free`s `fieldinit` used also in `enclosing`)
$(LI $(BUGZILLA 11805): Removal of Bool has critically broken expression evaluation)
$(LI $(BUGZILLA 11818): Ternary operator not allowed in a value parameter anymore)
$(LI $(BUGZILLA 11822): `-de` switch causees ICE with `auto` return and other stuff)
$(LI $(BUGZILLA 11824): A stack variable escaping problem in CTFE Phobos code)
$(LI $(BUGZILLA 11844): ICE$(LPAREN)template.c:6643$(RPAREN) Assertion failed: $(LPAREN)td->semanticRun != PASSinit$(RPAREN))
$(LI $(BUGZILLA 11849): Recursive enum causes segfault)
$(LI $(BUGZILLA 11850): [ICE] Problem with filter with signed-unsigned array comparison)
$(LI $(BUGZILLA 11852): RDMD broken on the Github HEAD)
$(LI $(BUGZILLA 11854): Git-head does not build with Visual Studio)
$(LI $(BUGZILLA 11863): std.conv.to!string$(LPAREN)int/uint, radix$(RPAREN) returns incorrect string)
$(LI $(BUGZILLA 11868): ICE$(LPAREN)template.c$(RPAREN) on passing `inout const` argument as TemplateTupleParameter)
$(LI $(BUGZILLA 11896): [REG2.066a] isVirtualMethod related GitHub HEAD regression $(LPAREN)works with 2.064$(RPAREN))
$(LI $(BUGZILLA 11914): Missed tuple unpacking in foreach for cartesianProduct)
$(LI $(BUGZILLA 11919): GitHub HEAD regression for getAttributes trait $(LPAREN)DMD CORE DUMP$(RPAREN))
$(LI $(BUGZILLA 11922): [REG2.065a] ICE on nonexistent identifier in templated auto method)
$(LI $(BUGZILLA 11924): inout Variadic Template Parameters)
$(LI $(BUGZILLA 11925): [2.065] [REGRESSION] ICE in CompoundStatement::semantic)
$(LI $(BUGZILLA 11930): Github regression -- Alias this not considered in is$(LPAREN)T unused: U$(RPAREN) matching)
$(LI $(BUGZILLA 11931): Linkers "Symbol Undefined" again with dmd HEAD when -g specified)
$(LI $(BUGZILLA 11941): Errors when appending to aggregate member array in CTFE)
$(LI $(BUGZILLA 11956): dmd doesn't lookup /etc/dmd.conf)
$(LI $(BUGZILLA 11963): Regression$(LPAREN)2.065$(RPAREN) ICE$(LPAREN)parse.c$(RPAREN) Parser crash)
$(LI $(BUGZILLA 11965): Regression$(LPAREN)2.064$(RPAREN) Segfault on garbage)
$(LI $(BUGZILLA 11966): Regression 2.065.b1: inout$(LPAREN)const$(LPAREN)char$(RPAREN)$(RPAREN)[] doesn't convert to inout$(LPAREN)char$(RPAREN)[])
$(LI $(BUGZILLA 11967): Regression$(LPAREN)2.065$(RPAREN) ICE$(LPAREN)parse.c$(RPAREN) Parser crash)
$(LI $(BUGZILLA 11980): startaddress pragma broken $(LPAREN)DMD 2.061 regression$(RPAREN))
$(LI $(BUGZILLA 11993): [REG] typeof$(LPAREN)this$(RPAREN) in constraint of member function template should reflect method qualifier)
$(LI $(BUGZILLA 12002): Internal error: toir.c 181)
$(LI $(BUGZILLA 12008): alias this and "unable to resolve forward reference" error)
$(LI $(BUGZILLA 12010): [REG DMD2.065-b1] Undefined template symbols for static library linked with debug symbols)
$(LI $(BUGZILLA 12016): implicit immutable upcast becomes null in CTFE)
$(LI $(BUGZILLA 12017): DDoc leaves out the majority of documentation)
$(LI $(BUGZILLA 12023): Regression 2.065-b2: template mixin fails within template class)
$(LI $(BUGZILLA 12037): Link-failure with std.numeric.CustomFloat)
$(LI $(BUGZILLA 12044): Invalid code gen causes segfault)
$(LI $(BUGZILLA 12047): Regression $(LPAREN)2.065 git-head$(RPAREN): UDAs are not checked)
$(LI $(BUGZILLA 12070): Variant opCall not static)
$(LI $(BUGZILLA 12079): Internal error: backend/cod4.c 358 for associative array access)
$(LI $(BUGZILLA 12080): Internal error: backend/symbol.c 1035 for invariant)
$(LI $(BUGZILLA 12089): std.utf.validate and inout$(LPAREN)char[]$(RPAREN) failts to compile)
$(LI $(BUGZILLA 12144): [REG DMD2.064] Unresolved xopEquals when referenced by dynamic array constructor)
$(LI $(BUGZILLA 12158): ICE with .init of nonexisting selective import)
$(LI $(BUGZILLA 12160): UDA related regressions)
)
)
$(BUGSTITLE DMD Compiler bugs,

$(P
$(LI $(BUGZILLA 235): goto & scope: cannot goto forward into different try block level)
$(LI $(BUGZILLA 275): Undefined identifier in instances of templates with forward mixins)
$(LI $(BUGZILLA 602): Compiler allows a goto statement to skip an initalization)
$(LI $(BUGZILLA 899): structure field .offsetof property inaccessible in the scope)
$(LI $(BUGZILLA 900): changing import order causes type mismatch)
$(LI $(BUGZILLA 918): $(LPAREN)D1 only$(RPAREN): Template order matter, version block change something with typedef, and another template bug.)
$(LI $(BUGZILLA 1687): "extern $(LPAREN)C++$(RPAREN) interface" and vtbl)
$(LI $(BUGZILLA 1748): Wrong stringof for templated classes)
$(LI $(BUGZILLA 2481): mixing field into anonymous struct inside class generates field overlapping vtable)
$(LI $(BUGZILLA 2806): enum member cannot be forward referenced)
$(LI $(BUGZILLA 2885): Silent forward reference bug using ReturnType)
$(LI $(BUGZILLA 3013): Duplicate error message on calling a function with a type)
$(LI $(BUGZILLA 3107): [meta] Property syntax)
$(LI $(BUGZILLA 3226): -fPIC flag doesn't seem to work)
$(LI $(BUGZILLA 3279): $(LPAREN)D1 only$(RPAREN) Confusing error message when comparing types)
$(LI $(BUGZILLA 3307): Template alias default parameters aren't resolved properly)
$(LI $(BUGZILLA 3753): ICE$(LPAREN)eh.c$(RPAREN):  Related to exception handling and alloca.)
$(LI $(BUGZILLA 3817): Array op: wrong error message)
$(LI $(BUGZILLA 3834): forward reference in templated class)
$(LI $(BUGZILLA 3903): Traits compiles as true for an array sum with wrong syntax)
$(LI $(BUGZILLA 3970): Problem with cast -1.0L ==> uint/ulong)
$(LI $(BUGZILLA 3991): Void initializers in unions considered overlapping)
$(LI $(BUGZILLA 4145): cross alias  namespace can't be resolve)
$(LI $(BUGZILLA 4162): pass by alias offset problems)
$(LI $(BUGZILLA 4983): [ICE] Stack overflow while initializing struct member with address of one of its methods)
$(LI $(BUGZILLA 5569): 64 bit Dwarf symbolic debug info not recognized by gdb)
$(LI $(BUGZILLA 5878): Forward reference in returning superclass from template using is$(LPAREN)$(RPAREN) expression $(LPAREN)Breaks std.traits.BaseTypeTuple$(RPAREN))
$(LI $(BUGZILLA 6010): -fPIC is broken on freebsd/64)
$(LI $(BUGZILLA 6382): edge case with static foreach)
$(LI $(BUGZILLA 6439): [CTFE] union fields are initialized independently)
$(LI $(BUGZILLA 6764): IFTI fails on typesafe variadic function over static array with non IntegerLiteral length)
$(LI $(BUGZILLA 6796): Several __error with wrong enum definition)
$(LI $(BUGZILLA 7077): $(LPAREN)D1 only$(RPAREN) mixin statements can invade the enclosing scope)
$(LI $(BUGZILLA 7175): Zero-length static array .ptr is always null)
$(LI $(BUGZILLA 7472): Cast from class to basic type not rejected during semantic)
$(LI $(BUGZILLA 7645): ICE$(LPAREN)e2ir.c$(RPAREN) nested classes)
$(LI $(BUGZILLA 7744): Forward reference in string mixin)
$(LI $(BUGZILLA 7966): First template instantiation inside `with` results in `Error 42: Symbol Undefined`)
$(LI $(BUGZILLA 8019): $(LPAREN)D1 only$(RPAREN) can't convert [] to int[])
$(LI $(BUGZILLA 8117): Cannot initialize struct member without default constructor)
$(LI $(BUGZILLA 8179): ICE$(LPAREN)e2ir.c$(RPAREN) with failed fixed size array cast)
$(LI $(BUGZILLA 8200): DMD segfault: template aliasing result of map)
$(LI $(BUGZILLA 8244): cannot slice a type tuple with '[]' in locations where a type is valid)
$(LI $(BUGZILLA 8255): [CTFE] ICE when passing 'ref' literal)
$(LI $(BUGZILLA 8313): stack overflow on recursive ifti evaluation)
$(LI $(BUGZILLA 8365): Static fixed size array of enums initialization fails)
$(LI $(BUGZILLA 8396): wrong order of evaluation for tuple expansion in function arguments)
$(LI $(BUGZILLA 8492): can't infer type in static assert)
$(LI $(BUGZILLA 8511): Segfault with forward-referenced enum)
$(LI $(BUGZILLA 8525): optimizer loops infinitely)
$(LI $(BUGZILLA 8543): simd literals need better CTFE support)
$(LI $(BUGZILLA 8581): Internal error: backend/cod1.c 1677 on structs with bitfields $(LPAREN)when compile with release or optimize parameter$(RPAREN))
$(LI $(BUGZILLA 8648): No error line number with incomplete template)
$(LI $(BUGZILLA 8658): Passing large structs to function b value causes stack corruption)
$(LI $(BUGZILLA 8664): Compiler causes stack overflow with recursive typedef and option -g)
$(LI $(BUGZILLA 8711): ICE with initializing function pointer with array)
$(LI $(BUGZILLA 8722): foreach triggers a floating point exception with multidimensional array of a dimension equal to 0)
$(LI $(BUGZILLA 8735): ICE: Assertion failure: 't' on line 100 in file 'aliasthis.c')
$(LI $(BUGZILLA 8739): DDoc outputs wrong parameter name in delegate parameter list)
$(LI $(BUGZILLA 8825): Wrong line number of error message)
$(LI $(BUGZILLA 8903): Bad code for enum array members)
$(LI $(BUGZILLA 8997): template instances omit symbol that may be used in other modules)
$(LI $(BUGZILLA 9008): Another forward referencing bug)
$(LI $(BUGZILLA 9050): Too early instantiation of template structs)
$(LI $(BUGZILLA 9081): Modules shouldn't have a type)
$(LI $(BUGZILLA 9212): Associative array foreach iteration with immutable key)
$(LI $(BUGZILLA 9256): A purity-related error message in case of member access)
$(LI $(BUGZILLA 9271): Forwarding lambda predicate with type inference causes segfault)
$(LI $(BUGZILLA 9296): LITTLE_ENDIAN and BIG_ENDIAN are always defined on Linux)
$(LI $(BUGZILLA 9301): using XMM.PSHUFD results in an internal compiler error)
$(LI $(BUGZILLA 9356): -inline with inout and append generates wrong code)
$(LI $(BUGZILLA 9459): Front-end does not detect invalid array operations)
$(LI $(BUGZILLA 9466): Compiler crash with code-coverage generation with large files)
$(LI $(BUGZILLA 9504): typeof does not look up properties correctly on template argument)
$(LI $(BUGZILLA 9562): Built-in runtime properties should become error with `Type.prop`)
$(LI $(BUGZILLA 9572): Missed wrong implicit integral conversion)
$(LI $(BUGZILLA 9577): Crash on static array of function literals)
$(LI $(BUGZILLA 9644): Spell checker gives silly suggestions for 1-2 character symbols)
$(LI $(BUGZILLA 9662): Implement RDMD test suite)
$(LI $(BUGZILLA 9690): cannot access to @disable'd symbol from inner function of another @disable'd)
$(LI $(BUGZILLA 9741): undefined identifier with User Defined Attribute)
$(LI $(BUGZILLA 9765): Error message with __error with struct literal dotvar expression)
$(LI $(BUGZILLA 9807): with statement does not work with alias this)
$(LI $(BUGZILLA 9831): Error message with failed lambda inference)
$(LI $(BUGZILLA 9861): Spurious 'is used as type' error with failed template instantiation)
$(LI $(BUGZILLA 9912): Wrong codegen when using tuple over member variable in more than one method)
$(LI $(BUGZILLA 10207): Alias and @attributes: Assertion failure: '!udas' on line 3132 in file 'parse.c')
$(LI $(BUGZILLA 10224): core.simd ICE cgcv.c line 2162 when compiling with -g)
$(LI $(BUGZILLA 10251): CTFE: Allow returning pointers to global static variables of known value)
$(LI $(BUGZILLA 10259): ICE on invalid compile-time class instantiation)
$(LI $(BUGZILLA 10312): compiler assert failure with ctfe on simd vector type)
$(LI $(BUGZILLA 10313): inout constructor + IFTI + has indirections arg doesn't work)
$(LI $(BUGZILLA 10329): Attributes not inferred for indirectly templated methods)
$(LI $(BUGZILLA 10391): Segfault compiling on Mac OS 10.8)
$(LI $(BUGZILLA 10459): align$(LPAREN)16$(RPAREN) does not work on Win64 with seperate compilation)
$(LI $(BUGZILLA 10483): ICE$(LPAREN)expression.c$(RPAREN) .init of struct with block initialized 2D static array)
$(LI $(BUGZILLA 10598): Using not-imported type - AssertFail: 'global.errors' line 6040 'template.c')
$(LI $(BUGZILLA 10632): [ICE]$(LPAREN)glue.c line 1227$(RPAREN) With inlining and tuples)
$(LI $(BUGZILLA 10635): Error: cannot use array to initialize S)
$(LI $(BUGZILLA 10643): Refused const array struct field initialized with void)
$(LI $(BUGZILLA 10747): Win64: warning about non-existing vc100.pdb)
$(LI $(BUGZILLA 10770): is$(LPAREN)T BASE==enum$(RPAREN) with tag enum T - AssertFail:'type' line 428 declaration.c)
$(LI $(BUGZILLA 10805): wrong error message for wrong delimited string)
$(LI $(BUGZILLA 10883): [ICE] Internal error: ../ztc/cod4.c 358 when compiling with -inline)
$(LI $(BUGZILLA 10905): [ICE]$(LPAREN)ctfeexpr.c line 355$(RPAREN) with ulong2 in structs)
$(LI $(BUGZILLA 10922): Compiler segfaults when using __traits$(LPAREN)parent, {}$(RPAREN))
$(LI $(BUGZILLA 10926): Wrong expression printed when ternary operator used as lvalue)
$(LI $(BUGZILLA 10927): Power of complex number causes an internal error)
$(LI $(BUGZILLA 10938): ICE on recursive instantiation in opDispatch)
$(LI $(BUGZILLA 11019): fwd reference : legal in C++, CT error in D $(LPAREN)unable to resolve forward reference in definition$(RPAREN))
$(LI $(BUGZILLA 11034): ICE: Assertion failed: $(LPAREN)!scope$(RPAREN), function toObjFile, file toobj.c, line 366.)
$(LI $(BUGZILLA 11155): Wrong SIMD code generated $(LPAREN)unaligned movaps$(RPAREN))
$(LI $(BUGZILLA 11193): [ICE] String template argument mixed with variadic template arguments causes ICE)
$(LI $(BUGZILLA 11198): Error messages for declaring a 'version' inside main$(LPAREN)$(RPAREN) and other functions are unclear)
$(LI $(BUGZILLA 11215): `inout` lose enclosing `shared` on resolution)
$(LI $(BUGZILLA 11224): Inlining stops NRVO)
$(LI $(BUGZILLA 11247): Error: typeof$(LPAREN)i$(RPAREN).sizeof is used as a type)
$(LI $(BUGZILLA 11286): Impure dtor makes "cannot call impure function" error, although it won't actually be called.)
$(LI $(BUGZILLA 11288): dmd assertion when assigning to $(LPAREN)static$(RPAREN) opDispatch)
$(LI $(BUGZILLA 11297): [ICE]$(LPAREN)glue.c line 868$(RPAREN) with a string concat in global enum lambda)
$(LI $(BUGZILLA 11314): inline ice with tuple assignment and if/else again)
$(LI $(BUGZILLA 11317): glue.c:1218: virtual unsigned int Type::totym$(LPAREN)$(RPAREN): Assertion `0` failed.)
$(LI $(BUGZILLA 11322): ICE with -inline cgcs.c 221)
$(LI $(BUGZILLA 11332): ICE$(LPAREN)dt.c$(RPAREN) and missing error when interpreting an unimplemented builtin)
$(LI $(BUGZILLA 11371): core.simd and ctfe)
$(LI $(BUGZILLA 11375): [profile+nothrow] Semantic 'no throw' error with -profile switch)
$(LI $(BUGZILLA 11376): ICE on __traits$(LPAREN)compiles, ...$(RPAREN) with invalid array-op)
$(LI $(BUGZILLA 11383): Some array casts incorrectly rejected in safe code)
$(LI $(BUGZILLA 11385): XXX is a nested function and cannot be accessed from XXX)
$(LI $(BUGZILLA 11394): NRVO should work for object field initialization in constructor)
$(LI $(BUGZILLA 11406): ld.gold breaks switch table jumps)
$(LI $(BUGZILLA 11425): Broken shadowing variable diagnostic)
$(LI $(BUGZILLA 11427): anonymous unions break structs in @safe code)
$(LI $(BUGZILLA 11445): adding double[string] causes crash)
$(LI $(BUGZILLA 11479): template members ignore private attribute in ddoc)
$(LI $(BUGZILLA 11484): [e2ir] Error in e2ir at cast to/from static array)
$(LI $(BUGZILLA 11485): [e2ir] Error in e2ir at numeric/bool to class/interface cast)
$(LI $(BUGZILLA 11489): Improper implicit cast to immutable.)
$(LI $(BUGZILLA 11497): lambda in "static if"/"assert" prevent inlining of function)
$(LI $(BUGZILLA 11518): DMD segfault on multiple template match)
$(LI $(BUGZILLA 11534): [CTFE] inout + returning a pointer into a member array)
$(LI $(BUGZILLA 11540): [ICE] CTFE segfault with try-catch-finally and goto)
$(LI $(BUGZILLA 11552): Missing label is not caught during semantic)
$(LI $(BUGZILLA 11562): Goto into or out of finally block is not caught during semantic)
$(LI $(BUGZILLA 11565): [Optimizer] Zeroes out the higher 32bits of register in ?: expression)
$(LI $(BUGZILLA 11587): Cannot compare AAs at compile time)
$(LI $(BUGZILLA 11618): Internal Compiler Error)
$(LI $(BUGZILLA 11627): [CTFE] cannot cast dchar to char at compile time on AA assignment)
$(LI $(BUGZILLA 11629): [CTFE] crash on AA.rehash)
$(LI $(BUGZILLA 11635): RDMD eats the -op flag when it should just pass through)
$(LI $(BUGZILLA 11653): No error when forgetting break with range cases.)
$(LI $(BUGZILLA 11656): property offsetof does not work with __vector fields)
$(LI $(BUGZILLA 11661): Meaningless error: "a struct is not a valid initializer for a void function$(LPAREN)$(RPAREN)")
$(LI $(BUGZILLA 11664): A function with a local static variable is unusable in CTFE)
$(LI $(BUGZILLA 11689): deprecated local function does not work)
$(LI $(BUGZILLA 11696): C++ incorrect static member mangling)
$(LI $(BUGZILLA 11722): Qualifier-only casts should not invoke opCast)
$(LI $(BUGZILLA 11726): ICE with ufcs on undefined identifier and opDispatch)
$(LI $(BUGZILLA 11727): Repeated error message with using forward referenced enum as variable)
$(LI $(BUGZILLA 11735): pragma$(LPAREN)msg, ...$(RPAREN) fails to print wstring, dstring)
$(LI $(BUGZILLA 11745): Unittests retrieved by __traits$(LPAREN)getUnitTests$(RPAREN) can not be invoked if private.)
$(LI $(BUGZILLA 11748): [ICE] function call as alias parameter of template gives ICE)
$(LI $(BUGZILLA 11749): switch case fallthrough error is enabled with -w, but cannot be made informational warning)
$(LI $(BUGZILLA 11750): ICE with debug info and empty #line Filespec)
$(LI $(BUGZILLA 11756): Irrelevant variable name printing in CTFE error message)
$(LI $(BUGZILLA 11769): Wrong line number in "matches both" error message)
$(LI $(BUGZILLA 11785): Order of method/function declarations has an effect on compilation result.)
$(LI $(BUGZILLA 11790): ICE$(LPAREN)interpret.c$(RPAREN): passing creation of array with type string as size to CTFE)
$(LI $(BUGZILLA 11793): [ICE] Compiler runs out of memory with trivial program: class with own class member instance)
$(LI $(BUGZILLA 11800): alias this matching incorrectly changes lvalue-ness)
$(LI $(BUGZILLA 11802): Wrong vtbl order for extern$(LPAREN)C++$(RPAREN) classes with overloaded functions on win32)
$(LI $(BUGZILLA 11813): Improve IFTI error diagnostic)
$(LI $(BUGZILLA 11814): Unnecessary error messages "does not match ..." on IFTI failure)
$(LI $(BUGZILLA 11843): Template instantiated twice: failed semantic analysis)
$(LI $(BUGZILLA 11875): static if template type deduction causes infinite recursion with recursive alias this)
$(LI $(BUGZILLA 11926): Segmentation fault when using const in an enum)
$(LI $(BUGZILLA 11944): ICE$(LPAREN)expression.c$(RPAREN) Assertion `f` failed.)
$(LI $(BUGZILLA 11968): ICE$(LPAREN)expression.c$(RPAREN) Crash when deleting __FILE__)
$(LI $(BUGZILLA 11969): ICE$(LPAREN)statement.c$(RPAREN) When mixing in a array literal containing errors)
$(LI $(BUGZILLA 11974): ICE$(LPAREN)cast.c$(RPAREN) Segfault with invalid assignment)
$(LI $(BUGZILLA 11982): ICE$(LPAREN)func.c$(RPAREN) With function literal with no body)
$(LI $(BUGZILLA 12038): alias this and &this cause ICE)
$(LI $(BUGZILLA 12040): Compiler segfault with circular reference in variable type)
$(LI $(BUGZILLA 12051): Wrong code with ?: resulting in char on x86-64)
$(LI $(BUGZILLA 12095): Wrong code with -O -inline)
)
)
$(BUGSTITLE DMD Compiler enhancements,

$(P
$(LI $(BUGZILLA 3597): Need single source for parser and documentation grammar.)
$(LI $(BUGZILLA 5109): some advise)
$(LI $(BUGZILLA 5746): Make std.range.iota strongly pure)
$(LI $(BUGZILLA 6930): combined type of immutable$(LPAREN)T$(RPAREN) and inout$(LPAREN)T$(RPAREN) should be inout$(LPAREN)const$(LPAREN)T$(RPAREN)$(RPAREN))
$(LI $(BUGZILLA 9477): String $(LPAREN)and array$(RPAREN) comparisons are needlessly very slow)
$(LI $(BUGZILLA 10199): labels cannot be used without a statement)
$(LI $(BUGZILLA 11284): add -allinst compiler switch)
$(LI $(BUGZILLA 11365): Allow D source file names to have no extension $(LPAREN)or an arbitrary extension$(RPAREN) when -run is used)
$(LI $(BUGZILLA 11417): rotate with immediate not recognized by optimizer)
$(LI $(BUGZILLA 11510): Relax restriction for overlapped pointer field access in safe code/during CTFE)
$(LI $(BUGZILLA 11533): Compiler should allow to being nested for static local template functions)
$(LI $(BUGZILLA 11546): string import dependency failure)
$(LI $(BUGZILLA 11711): Add __traits$(LPAREN)getAliasThis$(RPAREN))
$(LI $(BUGZILLA 11759): Poor error message trying to use lowercase L in literal suffix.)
$(LI $(BUGZILLA 11840): Show all errors of undefined identifier used in a line)
)
)
$(BUGSTITLE Phobos regressions,

$(P
$(LI $(BUGZILLA 1832): reading/writing an archive causes data loss; std.zip horribly broken)
$(LI $(BUGZILLA 11309): std.concurrency: OwnerTerminated message doesn't work)
$(LI $(BUGZILLA 11512): Can't build Phobos docs with win32 makefile)
$(LI $(BUGZILLA 11527): JSONValue cannot set values through named fields)
$(LI $(BUGZILLA 11528): appender: crash with -inline -O)
$(LI $(BUGZILLA 11576): std.algorithm.remove!$(LPAREN)SwapStrategy.unstable$(RPAREN) overruns array bounds)
$(LI $(BUGZILLA 11583): bigint bug)
$(LI $(BUGZILLA 11591): std.typecons.Tuple -s with classes fails at runtime as associative array keys)
$(LI $(BUGZILLA 11603): std.algorithm.canFind does not work when needle is 1-byte zero)
$(LI $(BUGZILLA 11671): ctRegex broken)
$(LI $(BUGZILLA 11684): SIGSEGV with ld.bfd version 2.22)
$(LI $(BUGZILLA 11692): can't set file attributes for std.zip.ArchiveMember)
$(LI $(BUGZILLA 11764): [REG2.065a]std.getopt broken)
$(LI $(BUGZILLA 11831): std.zip no longer allows setting madeVersion field in zip file)
$(LI $(BUGZILLA 11838): Missing emplace import for std.range.zip?)
$(LI $(BUGZILLA 11853): Tuples fail "isAssignable")
$(LI $(BUGZILLA 11973): std/datetime.d$(LPAREN)14647$(RPAREN): Deprecation: function std.algorithm.canFind!$(LPAREN)not$(RPAREN).canFind!$(LPAREN)immutable$(LPAREN)dchar$(RPAREN)[]$(RPAREN).canFind is deprecated - Please use any instead)
$(LI $(BUGZILLA 12024): [REG DMD2.065-b2] template instantiation for swap$(LPAREN)SysTime, SysTime$(RPAREN) fails)
$(LI $(BUGZILLA 12071): Algebraic won't take delegate returning structure)
$(LI $(BUGZILLA 12098): libcurl bad argument on handle null)
$(LI $(BUGZILLA 12135): [AA] Format tail after associative array value is treated as separator if explicit separator is empty)
$(LI $(BUGZILLA 12168): [REG2.065a] Add ref to array$(LPAREN)$(RPAREN) and object$(LPAREN)$(RPAREN) of JSONValue getters to add new element)
)
)
$(BUGSTITLE Phobos bugs,

$(P
$(LI $(BUGZILLA 1804): Severe GC leaks with repetitive array allocations)
$(LI $(BUGZILLA 2162): Access violation when threads run closures)
$(LI $(BUGZILLA 4301): BigInt * const$(LPAREN)BigInt$(RPAREN) doesn't work well)
$(LI $(BUGZILLA 4673): Bug in std.string $(LPAREN)isNumeric$(RPAREN))
$(LI $(BUGZILLA 4874): std.numeric.dotProduct doesn't work with bigints)
$(LI $(BUGZILLA 5280): to!FP$(LPAREN)Hex float string$(RPAREN) doesn't work well)
$(LI $(BUGZILLA 5762): getopt: short option parameter read incorrectly when bundling enabled)
$(LI $(BUGZILLA 5977): String splitting with empty separator)
$(LI $(BUGZILLA 6730): std.algorithm.splitter conflicts with std.array.splitter)
$(LI $(BUGZILLA 7069): Variant Doesn't Handle Const or Immutable Contents)
$(LI $(BUGZILLA 7689): splitter$(LPAREN)$(RPAREN) on ivalid UTF-8 sequences)
$(LI $(BUGZILLA 8013): splitter$(LPAREN)$(RPAREN) and split$(LPAREN)$(RPAREN) give different results)
$(LI $(BUGZILLA 8203): Use of std.regex.match$(LPAREN)$(RPAREN) generates "not enough preallocated memory" error)
$(LI $(BUGZILLA 8291): dirEntry cannot handle root directories + unhandled exception causes crash)
$(LI $(BUGZILLA 8298): dirEntries special linux file in Home dir)
$(LI $(BUGZILLA 8877): std.encoding.transcode is extremely slow)
$(LI $(BUGZILLA 9528): std.array.appender can't append elements with const members)
$(LI $(BUGZILLA 9645): std.algorithm.splitter on string with char as separator performs badly in certain situations)
$(LI $(BUGZILLA 9823): Delegate accepting element not accepted in std.range.put)
$(LI $(BUGZILLA 10569): std.traits: EnumMembers, isExpressionTuple, isTypeTuple & Largest balks at large input)
$(LI $(BUGZILLA 10571): formattedWrite error with delegate and string)
$(LI $(BUGZILLA 10710): shared phobos library doesn't work on all linux distributions)
$(LI $(BUGZILLA 10864): [REG 2.064][PERFORMANCE] new Safe appender is slower than "~=")
$(LI $(BUGZILLA 11005): std.xml does not encode attributes)
$(LI $(BUGZILLA 11110): Variant.convertsTo doesn't work like isImplicitlyConvertible)
$(LI $(BUGZILLA 11112): Unable to execute shell commands in different threads)
$(LI $(BUGZILLA 11148): Can't implicitly convert const$(LPAREN)BigInt$(RPAREN) or immutable$(LPAREN)BigInt$(RPAREN) to BigInt)
$(LI $(BUGZILLA 11180): Launching a process from a Windows GUI process using std.process.spawnProcess always fails)
$(LI $(BUGZILLA 11403): functions in std.algo can't be used as pred)
$(LI $(BUGZILLA 11459): std.container.Array bool constraint ambiguity)
$(LI $(BUGZILLA 11568): can't compile std.stdio.rawWrite with -m64 in Windows)
$(LI $(BUGZILLA 11600): to!BigInt$(LPAREN)string$(RPAREN) accepts non-numeric input)
$(LI $(BUGZILLA 11606): Cannot instantiate Tuple of non printable)
$(LI $(BUGZILLA 11617): std.uni.normalize doesn't compile)
$(LI $(BUGZILLA 11652): Support numerical ^^ complex operations in std.complex)
$(LI $(BUGZILLA 11681): std.datetime.IntervalRange.opAssign with non-ref parameter is required)
$(LI $(BUGZILLA 11691): can't join pathSplitter with dirSeparator)
$(LI $(BUGZILLA 11713): std.string munch$(LPAREN)$(RPAREN) does not properly handle UTF strings.)
$(LI $(BUGZILLA 11738): partialShuffle actually shuffles the entire input)
$(LI $(BUGZILLA 11771): Unicode set intersection with char is broken)
$(LI $(BUGZILLA 11775): std.regex should check for valid repetition range in assert mode)
$(LI $(BUGZILLA 11780): RangeError in format for incomplete format specifier)
$(LI $(BUGZILLA 11808): std.uni.CodepointSet$(LPAREN)'А', 'Я'+1, 'а', 'я'+1$(RPAREN) asserts)
$(LI $(BUGZILLA 11839): std.regex capture group names should allow numbers to be in them)
$(LI $(BUGZILLA 11879): missing default User-Agent in std.net.curl)
$(LI $(BUGZILLA 11884): std.container.Array lacks a constructor from an input range)
$(LI $(BUGZILLA 12069): ctRegex is 3x slower then R-T ?)
)
)
$(BUGSTITLE Phobos enhancements,

$(P
$(LI $(BUGZILLA 3868): It would be nice to have a function which read a file lazily using a range)
$(LI $(BUGZILLA 4859): Another File.byChunk$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 4909): Two suggestions for std.algorithm.schwartzSort$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 5611): back$(LPAREN)$(RPAREN) and front$(LPAREN)$(RPAREN) with ref return + opSlice$(LPAREN)$(RPAREN) in sort$(LPAREN)$(RPAREN) constraint)
$(LI $(BUGZILLA 6986): SortedRange[x..$] fails with unidentified __dollar)
$(LI $(BUGZILLA 8167): BigInt$(LPAREN)BigInt$(LPAREN)1$(RPAREN)$(RPAREN) too)
$(LI $(BUGZILLA 9061): BigInt | BigInt, BigInt & int)
$(LI $(BUGZILLA 11770): std.regex.Captures should be convertible to bool)
$(LI $(BUGZILLA 11789): No setAttributes to complement getAttributes)
$(LI $(BUGZILLA 11798): std.algorithm.all with no predicate too)
)
)
$(BUGSTITLE Druntime regressions,

$(P
$(LI $(BUGZILLA 11478): shared library on osx: worked in 2.062, fails in 2.063.2, still fails in 2.064)
)
)
$(BUGSTITLE Druntime bugs,

$(P
$(LI $(BUGZILLA 3454): Inconsistent flag setting in GC.realloc$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 4809): Stack trace when throwing exception misses location of the throw statement)
$(LI $(BUGZILLA 7508): float4 values aren't stored on initialisation)
$(LI $(BUGZILLA 8301): Access violation when a big array is allocated)
$(LI $(BUGZILLA 10701): [GC] segfault in GC)
$(LI $(BUGZILLA 11806): Freeze in GC.collect$(LPAREN)$(RPAREN) in in-contracts when multithreading is used)
)
)
$(BUGSTITLE Optlink regressions,

$(P
$(LI $(BUGZILLA 11559): Optlink crash with more than 2048 modules generated and debug info)
)
)
$(BUGSTITLE Optlink bugs,

$(P
$(LI $(BUGZILLA 2837): OPTLINK and LARGEADDRESSAWARE)
$(LI $(BUGZILLA 3956): linker removes underscore from all exported symbols of a module but the first)
$(LI $(BUGZILLA 6673): Map file contains broken lines on every 16,384 bytes)
$(LI $(BUGZILLA 7634): optlink creates bad debug info for a large number of modules)
)
)
$(BUGSTITLE Installer bugs,

$(P
$(LI $(BUGZILLA 10246): Windows installer still downloads from ftp.digitalmars.com)
$(LI $(BUGZILLA 11799): Incompatible argument types in create_dmd_release)
)
)
$(BUGSTITLE Installer enhancements,

$(P
$(LI $(BUGZILLA 10153): Beta releases should all have unique names)
)
)
$(BUGSTITLE Website regressions,

$(P
$(LI $(BUGZILLA 11449): Jump lists of phobos are in wrong order)
)
)
$(BUGSTITLE Website bugs,

$(P
$(LI $(BUGZILLA 5388): SList.insertFront has complexity O$(LPAREN)log$(LPAREN)n$(RPAREN)$(RPAREN))
$(LI $(BUGZILLA 9734): setIntersection accepts only 2 ranges, but documentation says otherwise)
$(LI $(BUGZILLA 10205): 'deprecated' '$(LPAREN)' assignExpression '$(RPAREN)' grammar is not documented)
$(LI $(BUGZILLA 10206): User-defined attributes not documented well in language specification)
$(LI $(BUGZILLA 10250): Grammar does not allow invariants in struct declarations)
$(LI $(BUGZILLA 10514): Constructor declaration grammar is incorrect)
$(LI $(BUGZILLA 11398): Language spec does not allow new eponymous template syntax)
$(LI $(BUGZILLA 11579): dlang.org repo can't be built without git)
$(LI $(BUGZILLA 11762): std.regex macro is not displayed/expanded properly)
)
)
$(BUGSTITLE Website enhancements,

$(P
$(LI $(BUGZILLA 11676): Add a link to D Wiki Sidebar to take users back to DLang.org)
$(LI $(BUGZILLA 12087): Add Readme to dlang.org repository that explains how to contribute)
)
)

)

$(VERSION 064, November 5, 2013, =================================================,

$(BUGSTITLE Language Enhancements,
$(LI $(RELATIVE_LINK2 import-package, Introduced the ability to define and import package modules.))
$(LI $(RELATIVE_LINK2 eponymous-template, Introduced a new eponymous template syntax.))
$(LI $(RELATIVE_LINK2 postfix-new, Postfix expressions are now allowed after a $(D new) expression.))
$(LI $(RELATIVE_LINK2 ifti-deduction, Implicit Function Template Instantiation now supports enclosing type/scope deduction.))
$(LI $(RELATIVE_LINK2 ddoc-warning, DDoc can now warn the user when the symbol names in a ddoc comment do not match the actual code.))
$(LI $(RELATIVE_LINK2 slice-pointer, Strings literals which are sliced are now implicitly convertible to a char pointer.))
$(LI $(RELATIVE_LINK2 function-template-overload, Templated and non-template functions can now be overloaded against each other.))
$(LI $(RELATIVE_LINK2 template-overload-set, Cross-module template declarations can now make an overload set.))
)

$(BUGSTITLE Compiler Changes,
$(LI $(RELATIVE_LINK2 deps-printing, Allow printing dependencies to stdout for tooling support.))
)

$(BUGSTITLE Compiler Enhancements,
$(LI $(RELATIVE_LINK2 getunittest-trait, Introduced the $(D getUnitTests) trait for retrieval and custom execution of unittests.))
$(LI $(RELATIVE_LINK2 getvirtualindex-trait, Introduced the $(D getVirtualIndex) trait to get the index of a virtual function.))
$(LI $(RELATIVE_LINK2 isoverridefunction-trait, Introduced the $(D isOverrideFunction) trait which indicates if a function is overridden or not.))
)

$(BUGSTITLE Phobos enhancements,
$(LI $(RELATIVE_LINK2 wrap-unwrap, Introduced the structural typesafe conversion functions $(D wrap) and $(D unwrap).))
$(LI $(RELATIVE_LINK2 pure-conv-format, $(D std.conv.to) and $(D std.string.format) are now pure functions.))
$(LI $(RELATIVE_LINK2 generic-strip, Introduced generic $(D strip)/$(D stripLeft)/$(D stripRight) functions.))
$(LI $(RELATIVE_LINK2 translate-buffer, Introduced an overload of $(D std.string.translate) which can take a buffer, avoiding the need for implicit memory allocations.))
$(LI $(RELATIVE_LINK2 current-path, Introduced the $(D thisExePath) function to retrieve the executable path of the currently running process.))
$(LI $(RELATIVE_LINK2 regex-api, New API for std.regex $(D match)/$(D replace) functions. ))
$(LI $(RELATIVE_LINK2 ct-regex, Compile-time $(D std.regex.ctRegex) now supports lookaround just like run-time one.))
)

$(BR)$(BIG $(RELATIVE_LINK2 list2064, List of all bug fixes and enhancements in D 2.064.))

$(HR)

$(BUGSTITLE Language Enhancements,

$(LI $(LEGACY_LNAME2 import_package, import-package, Introduced the ability to define and import package modules.)

$(P The new package import feature allows you to define a library module which has the purpose of publicly importing
any other modules in that library. The user can then simply import this one module and use the library as
if the user import all the modules at once. For example:)

$(P $(B libweb/client.d:))

---------
module libweb.client;

void runClient() { }
---------

$(P $(B libweb/server.d:))

---------
module libweb.server;

void runServer() { }
---------

$(P $(B libweb/package.d:))

---------
module libweb;

public import libweb.client;
public import libweb.server;
---------

$(P Notice that the package module must always have the file name $(D package.d). The module name
is the qualified name of the package. The user then uses the standard import syntax to import a
package module, simply using the module declaration name to import the package:)

$(P $(B test.d:))

---------
module test;

import libweb;

void main()
{
    startServer();
    startClient();
}
---------

$(P The following is an example of a package module of a sub-package:)

$(P $(B libweb/utils/package.d:))

---------
module libweb.utils;  // fully qualified name of the package, not just "utils"!

// publicly import modules from within the 'libweb.utils' package.
public import libweb.utils.conv;
public import libweb.utils.text;
---------

$(P To import this subpackage, use the standard module import declaration:)

$(P $(B test.d:))

---------
module test;

import libweb.utils;

void main()
{
}
---------

$(H3 Rationale:)

$(P Until now $(I public import) modules were implementable, but only by convention. The user would typically
have to import a specific module specified by the library author, e.g. $(D libweb.all) or $(D libweb._).
Introducing the package import feature standardizes this common convention of library authors)
)

$(LI $(LEGACY_LNAME2 eponymous_template, eponymous-template, Introduced a new eponymous template syntax.)

$(P The new eponymous template syntax allows you to write shorter templates without having to
explicitly define and repeat the template name when using traditional eponymous templates.
For example, before 2.064 eponymous templates were written and used like the following:)

---------
template Tuple(T...) { alias Tuple = T; }

template isIntOrFloat(T)
{
    static if (is(T == int) || is(T == float))
        enum isIntOrFloat = true;
    else
        enum isIntOrFloat = false;
}

void main()
{
    alias Tup = Tuple!(int, float, string);
    static assert(isIntOrFloat!(Tup[0]));  // int is an int or a float
    static assert(isIntOrFloat!(Tup[1]));  // float is an int or a float
    static assert(!isIntOrFloat!(Tup[2])); // string is neither an int nor a float
}
---------

$(P With the new eponymous syntax, the implementation code becomes much simpler:)

---------
alias Tuple(T...) = T;

enum isIntOrFloat(T) = is(T == int) || is(T == float);

void main()
{
    alias Tup = Tuple!(int, float, string);
    static assert(isIntOrFloat!(Tup[0]));  // int is an int or a float
    static assert(isIntOrFloat!(Tup[1]));  // float is an int or a float
    static assert(!isIntOrFloat!(Tup[2])); // string is neither an int nor a float
}
---------

$(P Notice how you need to start the declaration of such a template with an $(D alias) or $(D enum),
rather than starting it with the keyword $(D template).)

$(H3 Limitations:)

$(P Currently you cannot define template constraints for these types of templates.
This limitation may be lifted in a future release.)
)

$(LI $(LEGACY_LNAME2 postfix_new, postfix-new, Postfix expressions are now allowed after a $(D new) expression.)

$(P Before 2.064, you could not both instantiate a new class and call a method or access a property
of the object without having to wrap the $(D new) expression in parentheses:)

---------
class Server
{
    this(string[] args) { }
    void run() { }
}

void main(string[] args)
{
    (new Server(args)).run();
}
---------

$(P In 2.064 this limitation has been lifted, allowing you to write the code as follows:)

---------
class Server
{
    this(string[] args) { }
    void run() { }
}

void main(string[] args)
{
    new Server(args).run();
}
---------

$(P $(B Note:) When instantiating a class with the default constructor, you must insert
an empty set of parentheses before accessing a field or calling a method on the object:)

---------
class Server
{
    this() { }
    void run() { }
}

void main()
{
    new Server.run();    // error
    new Server().run();  // ok
}
---------
)

$(LI $(LEGACY_LNAME2 ifti_deduction, ifti-deduction, Implicit Function Template Instantiation now supports enclosing type/scope deduction:))

$(P IFTI has been improved, allowing you to write code such as the following:)

---------
struct A
{
    struct Foo { }
}

struct B
{
    struct Foo { }
}

/**
Templated function which expects the second argument to be of type 'Foo,
which is a nested in the type 'T'.
*/
void call(T)(T t, T.Foo foo) { }

void main()
{
    auto a = A();
    auto a_f = A.Foo();
    call(a, a_f);  // ok

    auto b = B();
    auto b_f = B.Foo();
    call(b, b_f);  // ok

    call(a, b_f);  // fails: b_f is typed as B.Foo, not A.Foo
}
---------

$(P This IFTI feature also allows you to retrieve the module of a symbol, by using an $(D alias)
template parameter, rather than a type one:)

---------
module my_module;

struct A
{
    struct B { }
}

void foo(alias Mod)(Mod.A, Mod.A.B)
{
    // 'Mod' is deduced to be the module 'my_module' which encloses the struct 'A'
    static assert(__traits(isSame, Mod, my_module));
}

void main()
{
    A a;
    A.B b;
    foo(a, b);  // ok
}
---------


$(LI $(LEGACY_LNAME2 ddoc_warning, ddoc-warning, DDoc can now warn the user when the symbol names in a ddoc comment do not match the actual code:))

$(P Here is an example documented function, where the parameter names are wrongly documented:)

---------
/**
    This is the sum function.

    params:
        x = The first parameter
        y = The second parameter
*/
int sum(int a, int b)
{
    return a + b;
}
---------

$(P Generating the documentation with warnings enabled will emit the following:)

$(CONSOLE
dmd -D -c -w test.d
)

$(CONSOLE
test.d(8): Warning: Ddoc: function declaration has no parameter 'x'
test.d(8): Warning: Ddoc: function declaration has no parameter 'y'
)

$(P This feature can help ensure that the documentation for library code is always kept up-to-date.)

$(P $(B Note:) Remember to use the $(B -w) switch when building the documentation with the $(B -D) switch
in order to enable these warnings.)

$(LI $(LEGACY_LNAME2 slice_pointer, slice-pointer, Strings literals which are sliced are now implicitly convertible to a char pointer:))

$(P To help ease interacting with C libraries which expect strings as null-terminated pointers,
slicing string $(B literals) (not variables!) will now allow the implicit conversion to such a pointer:)

---------
extern(C) void call(const(char)* str) { }

void main()
{
    const(char)* abc = "abc";
    call(abc);  // already previously allowed

    const(char)* ab = "abc"[0 .. 2];
    call(ab);   // allowed in 2.064
}
---------


$(LI $(LEGACY_LNAME2 function_template_overload, function-template-overload, Templated and non-template functions can now be overloaded against each other:))

---------
auto foo(int n) { return 1; }
auto foo(T)(T t) { return 2; }

void main()
{
    assert(foo(100) == 1);
    assert(foo("a") == 2);

    // Integer literal 10L can be converted to int without loss of precisions.
    // Then the call matches to foo(int n).
    assert(foo(10L) == 1);

    // A runtime variable 'num' typed long is not implicitly convertible to int.
    // Then the call matches to foo(T)(T t).
    long num = 10L;
    assert(foo(num) == 2);
}
---------


$(LI $(LEGACY_LNAME2 template_overload_set, template-overload-set, Cross-module template declarations can now make an overload set:))

$(P Template declarations are now overloadable just like regular function declarations. Templates with matching names from multiple modules will introduce an overload set:)

---------
module a;

template Traits(T) if (is(T == double))
{
    enum Traits = "abc";
}

auto func(T, A...)(A args) if (is(T == double))
{
    return 1;
}
---------
---------
module b;

template Traits(T) if (is(T == string))
{
    enum Traits = "def";
}

auto func(T, A...)(A args) if (is(T == string))
{
    return 2;
}
---------
---------
module c;
import a, b;
static assert(Traits!double == "abc");  // matches to a.Traits
static assert(Traits!string == "def");  // matches to b.Traits
void main()
{
    assert(func!double(1, "msg") == 1);  // matches to a.func(T, A...)
    assert(func!string(1, "msg") == 2);  // matches to b.func(T, A...)
}
---------

$(H3 Limitations:)

$(P Merging template overload sets by using an alias declaration is currently not supported.
The limitation will be lifted in a future release.)
)

$(BUGSTITLE Compiler Changes,

$(LI $(LEGACY_LNAME2 deps_printing, deps-printing, Allow printing dependencies to stdout for tooling support:))

$(P You can now use the $(B -deps) switch without having to specify a filename.
The dependencies will then be printed to standard output, allowing both users and tools
to introspect the dependencies in the output.)

$(P The types of dependencies which are printed out are as follows:)

$(P $(B depsImport): Module imports found (same as -deps=file output, except prefixed with depsImport))
$(P $(B depsVersion): Versions (except standard ones and ones set in the module itself))
$(P $(B depsFile): String imports found, e.g. $(D string x = import("foo.txt");))
$(P $(B depsLib): Libraries specified with a $(D pragma(lib) statement))
$(P $(B depsDebug): Any $(D debug()) statements found (except the ones set in the module itself))
)

$(BUGSTITLE Compiler Enhancements,
$(LI $(LEGACY_LNAME2 getunittest_trait, getunittest-trait, Introduced the $(D getUnitTests) trait for retrieval and custom execution of unittests:))

$(P With the new $(D getUnitTests) trait you can retrieve all unittest in a module or an
aggregate, and then run the tests manually. Here's an example of implementing a custom
unittest running routine which prints out some additional statistics:)

---------
import core.runtime;
import core.exception;
import std.stdio;

shared static this()
{
    // this overrides the default D runtime unittest runner function,
    // since we're providing a __traits-based one in our main function.
    Runtime.moduleUnitTester = { return true; };
}

unittest
{
    assert(1);  // passes.
}

unittest
{
    assert(0);  // fails.
}

unittest
{
    assert(1);  // passes.
}

void main()
{
    Throwable[] errors;  // collect all thrown exceptions.
    size_t passCount;    // count the number of unittests which pass.

    // iterate over each unittest (this is a tuple).
    foreach (test; __traits(getUnitTests, my_module))
    {
        try
        {
            test();
            passCount++;
        }
        catch (Throwable error)
        {
            errors ~= error;
        }
    }

    // print out the errors or the statistics.
    if (errors.length)
    {
        writeln("Some unittests failed:\n");
        foreach (error; errors)
            writeln(error);
    }
    else
    {
        writefln("All unittests passed. Passed unittest count: %s", passCount);
    }
}
---------

$(P $(B Note:) You must compile with the $(D -unittest) flag to be able to retrieve the unittests.)

$(P $(B Note:) By default the D runtime provides its own unittest execution function.
If you want to avoid it from being invoked at runtime (before the main function is called) you
need to set a custom one by assigning to $(D Runtime.moduleUnitTester) in the module constructor.
The one used in the above test-case simply returns $(D true), which allows the $(D main) function
to be called.)

$(P $(B Note:) The $(D getUnitTests) trait is not recursive. This means that calling it on a module
will not retrieve unittests which are nested in aggregates in that module.)

$(LI $(LEGACY_LNAME2 getvirtualindex_trait, getvirtualindex-trait, Introduced the $(D getVirtualIndex) trait to get the index of a virtual function:))

$(P You can use this trait to get the index of a virtual method in the virtual method table:)

---------
class C
{
    void foo() { }
    void bar() { }
}

class D : C
{
    void doo() { }
    void doo(int) { }
    void doo(double) { }
}

void main()
{
    /**
        Note that each class implicitly inherits from the Object class,
        so the following will most likely not begin with index 0.
    */
    pragma(msg, __traits(getVirtualIndex, D.foo));
    pragma(msg, __traits(getVirtualIndex, D.bar));

    /**
        When dealing with overloads you can use the getOverloads trait to index
        into a specific method
    */
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[0]));
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[1]));
    pragma(msg, __traits(getVirtualIndex, __traits(getOverloads, D, "doo")[2]));
}
---------

$(LI $(LEGACY_LNAME2 isoverridefunction_trait, isoverridefunction-trait, Introduced the $(D isOverrideFunction) trait which indicates whether or not a function is overriding:))

---
class Base
{
    void foo() { }
}

class Foo : Base
{
    override void foo() { }
    void bar() { }
}

static assert (__traits(isOverrideFunction, Base.foo) == false);
static assert (__traits(isOverrideFunction, Foo.foo)  == true);
static assert (__traits(isOverrideFunction, Foo.bar)  == false);
---
)

$(BUGSTITLE Phobos enhancements,

$(LI $(LEGACY_LNAME2 wrap_unwrap, wrap-unwrap, Introduced the structural typesafe conversion functions $(D wrap) and $(D unwrap):))

$(P Sometimes you may want your class to be usable with a function which expects a specific interface
argument type, but you do not necessarily want to edit the class to inherit that interface.
The class could also be implemented in another library for which you do not have the source code,
which means you wouldn't be able to edit the inheritance list of that class.)

$(P The new $(D wrap) function allows you to perform a $(I structural cast), allowing a class object to
act as if it were an object of another type. For example (note: for now please pass the -allinst flag to dmd when compiling):)

---------
import std.typecons;

interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
}

class ImageDraw  // note: it does not inherit IDrawable.
{
    void drawLine(int x1, int y1, int x2, int y2) { }
}

/** Draw a rectangle outline. */
void drawRect(IDrawable draw)
{
    draw.drawLine(  0,   0, 100,   0);
    draw.drawLine(100,   0, 100, 100);
    draw.drawLine(  0, 100, 100, 100);
    draw.drawLine(  0,   0,   0, 100);
}

void main()
{
    auto imageDraw = new ImageDraw();
    drawRect(imageDraw);  // error: can't call this, ImageDraw is not an IDrawable.

    // perform a structural cast.
    IDrawable i = wrap!IDrawable(imageDraw);
    drawRect(i);  // and now imageDraw can act as an IDrawable.
}
---------

$(P The $(D wrap) function can also be used with classes which define an $(D opDispatch) function, for example:)

---------
import std.typecons;

interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
    void drawRect(int x, int y, int width, int height);
}

class ImageDraw
{
    void opDispatch(string name, Args...)(Args args)
        if (name == "drawLine")
    {
        // ...
    }

    void opDispatch(string name, Args...)(Args args)
        if (name == "drawRect")
    {
        // ...
    }
}

/** Draw some shapes. */
void drawShapes(IDrawable draw)
{
    draw.drawLine(0, 100, 100, 0);
    draw.drawRect(0, 0, 100, 100);
}

void main()
{
    auto imageDraw = new ImageDraw();
    IDrawable i = wrap!IDrawable(imageDraw);
    drawShapes(i);
}
---------

$(P You can unwrap a structurally cast object back to its original type:)

---------
interface IDrawable
{
    void drawLine(int x1, int y1, int x2, int y2);
}

class ImageDraw
{
    void drawLine(int x1, int y1, int x2, int y2) { }
}

void main()
{
    auto imageDraw = new ImageDraw();

    // perform a structural cast (note the simple UFCS syntax).
    IDrawable i = imageDraw.wrap!IDrawable;

    // get back the original type (ditto, using UFCS syntax).
    ImageDraw draw = i.unwrap!ImageDraw;
}
---------

$(P And you can structurally cast to multiple interface types:)

---------
import std.typecons;

unittest
{
    interface IStoppable { void stop(); }
    interface IRunnable { void run(); }

    class Timer
    {
        void run() { }
        void stop() { }
    }

    auto timer = new Timer();
    auto obj = timer.wrap!(IStoppable, IRunnable);

    // extract the individual structurally casted types
    // from the wrapped type
    IStoppable iStop = obj;
    IRunnable  iRun  = obj;

    iRun.run();
    iStop.stop();
}
---------

$(LI $(LEGACY_LNAME2 pure_conv_format, pure-conv-format, $(D std.conv.to) and $(D std.string.format) are now pure functions:))

$(P Since 2.064, pure functions can take advantage of $(D to) and $(D format). For example:)

---------
import std.conv;
import std.string;

void main() pure  // this main is a pure function.
{
    string date = format("%s.%s.%s", 2013, 12, 10);
    int one = to!int(1.0);
}
---------

$(LI $(LEGACY_LNAME2 generic_strip, generic-strip, Introduced generic $(D strip)/$(D stripLeft)/$(D stripRight) functions:))

$(P The new generic strip functions allow you to not only strip strings but also any other Input range
($(D stripLeft)) or Bidirectional range ($(D strip)/$(D stripRight)), for example:)

---------
import std.algorithm;

void main()
{
    // strip whitespace.
    assert("  foobar  ".strip!(a => a == ' ')() == "foobar");

    // an audio waveform.
    float[] data = [0.0, 0.0, 0.1, 0.5, 0.2];

    // strip leading silence in the waveform.
    assert(data.strip!(a => a < 0.1)().length == 3);
}
---------

$(LI $(LEGACY_LNAME2 translate_buffer, translate-buffer, Introduced an overload of $(D std.string.translate) which can take a buffer, avoiding the need for implicit memory allocations:))

$(P To avoid implicit memory allocations $(D translate) now features overloads which can take an output range
to write the contents to. For example:)

---------
import std.array;
import std.string;

void main()
{
    dchar[dchar] transTable = ['a' : '1', 'b' : '2', 'c': '3'];

    // create our output range by using the Phobos Appender.
    auto buffer = appender!(dchar[])();

    auto toRemove = null;  // don't remove any characters.

    translate("abcdef", transTable, toRemove, buffer);
    assert(buffer.data == "123def");

    // or use a static array to avoid heap allocations.
    // note: if the buffer is too small an exception will be thrown.
    dchar[6] dbuffer;
    translate("abcdef", transTable, toRemove, dbuffer[]);
    assert(dbuffer == "123def");
}
---------

$(LI $(LEGACY_LNAME2 current_path, current-path, Introduced the $(D thisExePath) function to retrieve the executable path of the currently running process:))

$(P With the $(D thisExePath) function you can retrieve the current executable path:)

---------
import std.file;
import std.stdio;

void main(string[] args)
{
    // Prints the full path of the current running executable.
    // Note: this may, or may not be the same as args[0]. The content
    // of args[0] is dependent of how the application was invoked, thisExePath()
    // is not. It's also possible to access thisExePath() from other parts of the
    // code than main.
    writeln(thisExePath());
}
---------
$(LI $(LEGACY_LNAME2 regex_api, regex-api, New API for std.regex $(D match)/$(D replace) functions:))

$(P The old API based around "g"(=global) flag was confusing and error prone.
Moreover in some cases it was already being overriden by a function as is the case
with $(D std.regex.splitter).)

$(P New version ties the operation to the function in question, thus being simpler to
understand without extra context. For the moment the "g" flag is kept working as
is but the new API always overrides it where applicable. Another addition in the new
API is an overload for the $(D replace) family of functions to work directly with
output ranges.)

$(P To understand the difference in the API compare 2 samples below.)

$(P Before 2.064:)
---
void main()
{
    import std.regex, std.algorithm, std.range, std.stdio, std.string;
    auto m = "3.141592".match(`(\d+)\.(\d+)`);
    // m is a range of ranges
    assert(m.front.equal(["3.141592", "3", "141592"]));

    // global vs non-global
    auto word = regex(`(\w)\w*`);
    auto gword = regex(`(\w)\w*`, "g");
    auto list = "tomatoes, potatoes, pineapple";
    // this will print only 'tomatoes', which raised many questions
    foreach(item; list.match(word))
        writeln(item.hit);

    // while this will print each of them
    foreach(item; list.match(gword))
        writeln(item.hit);

    auto justFirst = replace!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(justFirst == "Tomatoes, potatoes, pineapple");
    auto allOfThem = replace!(m => toUpper(m[1]) ~ m[0].drop(1))(list, gword);
    assert(allOfThem == "Tomatoes, Potatoes, Pineapple");
}
---
$(P After 2.064:)
---
void main()
{
    import std.regex, std.algorithm, std.range, std.stdio, std.string;
    auto m = "3.141592".matchFirst(`(\d+)\.(\d+)`);
    // m is simply a range of submatches
    assert(m.equal(["3.141592", "3", "141592"]));

    auto word = regex(`(\w)\w*`);
    auto list = "tomatoes, potatoes, pineapple";
    // iterates over submatches so it will print 2 lines:
    // tomatoes
    // t
    foreach(item; list.matchFirst(word))
        writeln(item);
    // so just to get the whole match:
    assert(list.matchFirst(word).hit == "tomatoes");

    // now there is no need to check if it has "g" option
    // it's crystal clear in the function name
    foreach(item; list.matchAll(word))
        writeln(item.hit);

    auto justFirst = replaceFirst!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(justFirst == "Tomatoes, potatoes, pineapple");
    auto allOfThem = replaceAll!(m => toUpper(m[1]) ~ m[0].drop(1))(list, word);
    assert(allOfThem == "Tomatoes, Potatoes, Pineapple");

    // NEW feature - if there is no need to allocate, the resulting string
    // replacement may be just sent directly to the wire (an OutputRange)
    auto sink = stdout.lockingTextWriter();
    replaceAllInto!(m => toUpper(m[1]) ~ m[0].drop(1))(sink, list, word);
}
---

$(P The old API still works, even though eventual deprecation is planned.
Also note the new functionality in form of *Into functions that forward the
replacement directly to an output range avoiding extra pressure on the heap.)

$(LI $(LEGACY_LNAME2 ct_regex, ct-regex, Compile-time $(D std.regex.ctRegex) now supports lookaround just like run-time one:))

$(P Now $(D ctRegex) supports full syntax spectrum of run-time one except for set
algebra inside of a character class. For instance, the following now compiles and
passes:)
---
void main()
{
    import std.regex;
    // a word, but not a title-cased ASCII
    // ?<! inside of () means "negative lookbehind"
    auto pat = ctRegex!`\w+(?<![A-Z][a-z]*)`;
    assert(!"Hello".match(pat));
    assert("good_bay".match(pat));
}
---
)

$(BR)$(BIG $(LNAME2 list2064, List of all bug fixes and enhancements in D 2.064:))

$(BUGSTITLE DMD Compiler regressions,

$(P
$(LI $(BUGZILLA 6014): rt_finalize Segmentation fault , dmd 2.053 on linux & freebsd)
$(LI $(BUGZILLA 10074): segfault in dmd)
$(LI $(BUGZILLA 10197): [REG2.063] Cannot cast overloaded template property result)
$(LI $(BUGZILLA 10212): Segfault in mismatching delegate literal types)
$(LI $(BUGZILLA 10215): Regression $(LPAREN)2.063 release$(RPAREN): const causes wrong float calculation)
$(LI $(BUGZILLA 10220): `array` doesn't work with disabled default construction)
$(LI $(BUGZILLA 10255): When creating lib files, dmd no longer splits module into multiple obj files)
$(LI $(BUGZILLA 10299): [REG2.063] ICE with getting address of template)
$(LI $(BUGZILLA 10330): Regresfsion $(LPAREN)2.063.2$(RPAREN): __VERSION__ is set wrong)
$(LI $(BUGZILLA 10337): Error: mutable method glwtf.input.SignalWrapper!$(LPAREN)$(RPAREN).SignalWrapper.Signal!$(LPAREN)$(RPAREN).~this)
$(LI $(BUGZILLA 10352): Regression $(LPAREN)2.063$(RPAREN): --eval is broken in RDMD)
$(LI $(BUGZILLA 10357): std.typecons.Nullable!$(LPAREN)SysTime$(RPAREN).Nullable.__ctor!$(LPAREN)$(RPAREN) error instantiating)
$(LI $(BUGZILLA 10373): cannot resolve forward reference $(LPAREN)dmd2.063$(RPAREN))
$(LI $(BUGZILLA 10375): [REG2.061] private template from imported module hijacks a template type parameter$(LPAREN)!$(RPAREN))
$(LI $(BUGZILLA 10382): Regression $(LPAREN)2.059$(RPAREN): ICE when catching illegal type)
$(LI $(BUGZILLA 10394): opBinaryRight!"in" and tuple)
$(LI $(BUGZILLA 10397): ICE on concatenating string with unexisted symbol)
$(LI $(BUGZILLA 10425): Link error with templates)
$(LI $(BUGZILLA 10440): shared library on osx: worked in 2.062, fails in 2.063 / 2.063.2)
$(LI $(BUGZILLA 10441): Static libraries too big)
$(LI $(BUGZILLA 10456): struct containing enum X, alias X this and a dynamic array no longer compiles since 2.063)
$(LI $(BUGZILLA 10481): out of memory error)
$(LI $(BUGZILLA 10486): Segfault on assigning `typeof$(LPAREN)null$(RPAREN)` to static array)
$(LI $(BUGZILLA 10498): `__traits$(LPAREN)compiles, ...$(RPAREN)` affect program behaviour)
$(LI $(BUGZILLA 10503): Octal enums don't work anymore)
$(LI $(BUGZILLA 10505): anonymous enum members cannot have different types)
$(LI $(BUGZILLA 10537): Forward reference error on 'yield' toy example.)
$(LI $(BUGZILLA 10548): [REG 2.064a] argument has no identifier)
$(LI $(BUGZILLA 10558): Assertion failure on struct.c:741)
$(LI $(BUGZILLA 10561): Regression $(LPAREN)2.064 HEAD$(RPAREN): anon enum members no longer have enum base type)
$(LI $(BUGZILLA 10573): Weird linking problem with associative array cast [DMD 2.63])
$(LI $(BUGZILLA 10577): 2.063 Mixin Regression $(LPAREN)works with 2.062$(RPAREN))
$(LI $(BUGZILLA 10579): regression 062=>063: Cannot interpret TypeInfo at compile time)
$(LI $(BUGZILLA 10592): Regression of overloaded template function)
$(LI $(BUGZILLA 10600): regression$(LPAREN)2.063.2$(RPAREN) ICE: Assertion failed: $(LPAREN)type->ty != Tstruct || $(LPAREN)$(LPAREN)TypeStruct *$(RPAREN)type$(RPAREN)->sym == this$(RPAREN), function semantic, file struct.c, line 741.)
$(LI $(BUGZILLA 10612): Regression $(LPAREN)2.064 HEAD$(RPAREN): ICE on using enum as hash key with mutual module imports)
$(LI $(BUGZILLA 10617): contract with -profile -debug is not nothrow)
$(LI $(BUGZILLA 10624): [REG2.064a] ICE with tuple comparison)
$(LI $(BUGZILLA 10626): ICE with vector operation)
$(LI $(BUGZILLA 10628): [REG2.063] spurious "hidden by" deprecation warning)
$(LI $(BUGZILLA 10669): CTFE: using initialized static const class member no longer works)
$(LI $(BUGZILLA 10673): memory corruption in interpret.c)
$(LI $(BUGZILLA 10682): [ICE]$(LPAREN)cgcod.c line 1561$(RPAREN) with ^^ operator and ulong)
$(LI $(BUGZILLA 10684): Refused array op with array literal)
$(LI $(BUGZILLA 10687): Refused cast from uint[] to array of uint-based enums at compile-time)
$(LI $(BUGZILLA 10713): [REG2.063] ICE with typeof$(LPAREN)this.nonExistingField$(RPAREN) in method signature)
$(LI $(BUGZILLA 10721): ICE with constructor with postcondition)
$(LI $(BUGZILLA 10722): Regression $(LPAREN)2.064 git-head$(RPAREN): Cannot interpret struct at compile-time)
$(LI $(BUGZILLA 10726): Bogus Circular Reference error if opEquals defined and has a loop)
$(LI $(BUGZILLA 10727): Regression $(LPAREN)dmd-2.061$(RPAREN) -- DMD dumps core)
$(LI $(BUGZILLA 10734): Assertion failure: '0' on line 1546 in file 'cast.c')
$(LI $(BUGZILLA 10736): Regression $(LPAREN)2.064 git-head$(RPAREN): Instantiation failure triggered by module import and module order)
$(LI $(BUGZILLA 10744): [regression git-head v2.064] Rejects valid interface inheritance + wrong error message)
$(LI $(BUGZILLA 10782): dmd segfault with string mixin, CTFE, class, non-literal initializer)
$(LI $(BUGZILLA 10788): Regression: forward reference of enum member E from another module.)
$(LI $(BUGZILLA 10789): Struct destructor erroneously called)
$(LI $(BUGZILLA 10804): regression$(LPAREN)2.063=>2.064$(RPAREN) problem with Appender or dmd?)
$(LI $(BUGZILLA 10808): [REG2.064a] Incorrect typeid template argument should report error)
$(LI $(BUGZILLA 10836): 'errors compiling the function' for optimized builds)
$(LI $(BUGZILLA 10946): Integer constant expression expected instead of...)
$(LI $(BUGZILLA 10949): CTFE ICE after indexing error)
$(LI $(BUGZILLA 10964): [REG][2.063] Static array assign/blit exception slips through catch block.)
$(LI $(BUGZILLA 10981): Contracts in pure class methods are useless)
$(LI $(BUGZILLA 10994): [REG] cannot declare statics struct with void-initialized static arrays)
$(LI $(BUGZILLA 10998): [REG 2.063] compile-time postblit call check is incorrectly suppressed.)
$(LI $(BUGZILLA 11010): Regression $(LPAREN)2.063.2$(RPAREN) typeid doesn't work on a member of an instance.)
$(LI $(BUGZILLA 11039): Undefined instantiation from circular imports)
$(LI $(BUGZILLA 11054): ICE: interpret.c:357: virtual void Statement::ctfeCompile$(LPAREN)CompiledCtfeFunction*$(RPAREN): Assertion `0` failed.)
$(LI $(BUGZILLA 11062): inline ice with alias this and opIndexAssign)
$(LI $(BUGZILLA 11069): DMD $(LPAREN)github HEAD$(RPAREN) Linker Regression)
$(LI $(BUGZILLA 11081): Win64: duplicate COMDAT with failed compilation with lambdas)
$(LI $(BUGZILLA 11086): dmd segfault)
$(LI $(BUGZILLA 11105): Error on struct with multidimentional static array initialization from its element)
$(LI $(BUGZILLA 11117): Pseudo module __entrypoint.d listed as dependency with -deps)
$(LI $(BUGZILLA 11121): Wrong parenthesis omission in ddoc output)
$(LI $(BUGZILLA 11127): std.range.cycle linker errors)
$(LI $(BUGZILLA 11153): Regression $(LPAREN)2.064 git-head$(RPAREN): ICE during a diagnostic for missing return type)
$(LI $(BUGZILLA 11163): [ICE]$(LPAREN)ctfeexpr.c line 355$(RPAREN) with pragma$(LPAREN)msg$(RPAREN) of a wrong expression)
$(LI $(BUGZILLA 11186): Regression $(LPAREN)2.061$(RPAREN): Presence of Variant and const field invokes opAssign)
$(LI $(BUGZILLA 11197): [DMD 2.064a] Struct with postblit cannot be appended to an AA of arrays)
$(LI $(BUGZILLA 11203): extern $(LPAREN)C++$(RPAREN) classes broken)
$(LI $(BUGZILLA 11220): Regression in master: XXX__lambda2 cannot access frame of function XXX)
$(LI $(BUGZILLA 11223): inline ice with tuple assignment and if/else)
$(LI $(BUGZILLA 11225): Module dependency cycle causes import statements inside typeof$(LPAREN)$(RPAREN) expressions inside templates to fail)
$(LI $(BUGZILLA 11228): alias this confuses static array copy)
$(LI $(BUGZILLA 11230): [REG2.064a] Inexact mangling for template function literal.)
$(LI $(BUGZILLA 11233): DMD HEAD very slow with large static array struct field)
$(LI $(BUGZILLA 11237): zero initializer emitted to read-only data segment, slow compilation)
$(LI $(BUGZILLA 11242): [REG2.064beta] Fails to infer template argument with inout)
$(LI $(BUGZILLA 11245): [REG 2.063] Can't access length of static arrays from within classes)
$(LI $(BUGZILLA 11246): [REG 2.063] Struct initialized in constructor is destroyed first)
$(LI $(BUGZILLA 11256): Error mixing struct with disabled default construction and templated with lambda struct)
$(LI $(BUGZILLA 11261): Can't infer types without explicit slice in foreach)
$(LI $(BUGZILLA 11262): std.regex.replace does not accept StaticRegex)
$(LI $(BUGZILLA 11265): Segfault while calling instance method of class defined inside struct)
$(LI $(BUGZILLA 11267): Resulting executable sizes varies a lot)
$(LI $(BUGZILLA 11271): [REG 2.063] auto ref opAssign + destructor + struct literal fails)
)
)

$(BUGSTITLE DMD Compiler bugs,

$(P
$(LI $(BUGZILLA 952): Strange "Error:" prefix on some warning messages)
$(LI $(BUGZILLA 1982): [CTFE] Problems with compile-time null)
$(LI $(BUGZILLA 2407): function pointer as an enum's base type doesn't work)
$(LI $(BUGZILLA 2486): taking address of slice rvalue should not be allowed)
$(LI $(BUGZILLA 3096): EnumBaseType)
$(LI $(BUGZILLA 3646): Default values of function arguments are ignored when instantiating a template.)
$(LI $(BUGZILLA 3866): anonymous delegate with default parameters cross-talks to another anonymous  delegate)
$(LI $(BUGZILLA 4018): __FILE__ and __LINE__ as default template parameters not set to instantiation point per spec)
$(LI $(BUGZILLA 4481): ICE$(LPAREN)glue.c,!vthis->csym$(RPAREN) or compiles, depending on the import statements order)
$(LI $(BUGZILLA 4611): stack overflow or ICE$(LPAREN)cgcod.c$(RPAREN) when static array of structs exceeds 16MB limit)
$(LI $(BUGZILLA 4841): -inline wrecks certain nested structs causing error "*** is a nested function and cannot be accessed from ***")
$(LI $(BUGZILLA 4899): Ddoc: Warnings about stray parens do not include file and line numbers for module comments)
$(LI $(BUGZILLA 5012): ICE$(LPAREN)cod3.c$(RPAREN): handling a nested function in inline asm.)
$(LI $(BUGZILLA 5655): Lambda inside static foreach saves wrong value of counter)
$(LI $(BUGZILLA 5842): hash table corruption)
$(LI $(BUGZILLA 5911): Closure destroys the thrown Exception .)
$(LI $(BUGZILLA 5988): Template accepts instantiating an already-instantiated template type)
$(LI $(BUGZILLA 6107): ICE$(LPAREN)expression.c$(RPAREN) when a non-template member named '__ctor' exists in a struct, and the constructor is attempted to be invoked.)
$(LI $(BUGZILLA 6169): [CTFE] pure functions cannot compute constants using functions not marked as pure)
$(LI $(BUGZILLA 6178): Struct inside the AA are not init correctly)
$(LI $(BUGZILLA 6310): Missing "template instantiation" traceback when an error happens in the template parameter of an alias.)
$(LI $(BUGZILLA 6461): multiple definitions with typeid and multiobj)
$(LI $(BUGZILLA 6711): "with" doesn't work with "alias this")
$(LI $(BUGZILLA 6720): ICE$(LPAREN)cod1.c$(RPAREN) casting return of void function to bool)
$(LI $(BUGZILLA 6799): ICE$(LPAREN)type.c$(RPAREN) involving AAs and pointers to structs)
$(LI $(BUGZILLA 6906): Cannot assign value into associative array if contains opAssign)
$(LI $(BUGZILLA 7051): Class member with un-@safe destructor gives confusing error)
$(LI $(BUGZILLA 7156): ICE$(LPAREN)go.c$(RPAREN): with 199 or 200 repeated integer increments, only with -O)
$(LI $(BUGZILLA 7202): Hole in type system still present for delegates)
$(LI $(BUGZILLA 7254): ICE$(LPAREN)cod3.c$(RPAREN) returning strings as static arrays)
$(LI $(BUGZILLA 7436): ICE$(LPAREN)cg87.c$(RPAREN) ubyte = ubyte op= float)
$(LI $(BUGZILLA 7474): ICE$(LPAREN)cgcs.c$(RPAREN) on instantiating a struct with field and destructor as tuple)
$(LI $(BUGZILLA 7522): ICE$(LPAREN)interpret.c$(RPAREN) Accessing a non-static member without this)
$(LI $(BUGZILLA 7524): D1: #line __LINE__ doesn't parse)
$(LI $(BUGZILLA 7533): Error with no line number with pure static ctor)
$(LI $(BUGZILLA 7538): All kinds of property functions should be called before getting their types inside typeof)
$(LI $(BUGZILLA 7565): ICE$(LPAREN)cg87$(RPAREN):202, postincrement of a double parameter, 64-bit only)
$(LI $(BUGZILLA 7656): ddoc misinterprets commented parentheses in an example)
$(LI $(BUGZILLA 7715): DDoc eats $1, $2, $3 etc. inside d_code section)
$(LI $(BUGZILLA 7727): "static initializer" for non-static unions too)
$(LI $(BUGZILLA 7746): Error with 'TOK232' declaring enum of anonymous nested class type)
$(LI $(BUGZILLA 7780): Template mixin'd members do not properly overload)
$(LI $(BUGZILLA 7806): ICE$(LPAREN)gloop.c$(RPAREN) iterating with idouble, when compiling with -O)
$(LI $(BUGZILLA 7848): pure and nothrow ignored on unittest blocks)
$(LI $(BUGZILLA 7892): Compiler-generated struct copies can result in errors when ctor is @disable'd)
$(LI $(BUGZILLA 7976): ICE$(LPAREN)backend/cg87.c$(RPAREN)assignment btw two elements of dynamic array of complex number types)
$(LI $(BUGZILLA 7988): [CTFE] CTFE return values should be allowed in compile-time expressions)
$(LI $(BUGZILLA 8119): Cannot cast from void* to forwarded struct pointer)
$(LI $(BUGZILLA 8179): ICE$(LPAREN)e2ir.c$(RPAREN) with failed fixed size array cast)
$(LI $(BUGZILLA 8253): CTFE ICE: calling of member function of non-CTFE class variable)
$(LI $(BUGZILLA 8285): Issue with slice returned from CTFE function)
$(LI $(BUGZILLA 8352): Wrong "__overloadset isn't a template" error)
$(LI $(BUGZILLA 8360): Destruction of uninitialized temporary struct with assert)
$(LI $(BUGZILLA 8361): [ICE] $(LPAREN)eh.c line 316$(RPAREN) with struct with dtor in assert)
$(LI $(BUGZILLA 8441): mixin containing template functions causes compiler errors)
$(LI $(BUGZILLA 8563): Exception segfault)
$(LI $(BUGZILLA 8579): Default parameter appears a part of typeof$(LPAREN)$(RPAREN).stringof of a function variable)
$(LI $(BUGZILLA 8651): Slice op Slice throws exceptions $(LPAREN)not errors$(RPAREN), and nothrow)
$(LI $(BUGZILLA 8733): Normalize -of path on Windows)
$(LI $(BUGZILLA 8795): mixing in "switch" or "interface;" makes dmd segfault)
$(LI $(BUGZILLA 8911): -property makes fullyQualifiedName fail for functions)
$(LI $(BUGZILLA 8956): Ability to break typesystem with constructor/postblit/destructor $(LPAREN)e.g. modify immutable$(RPAREN))
$(LI $(BUGZILLA 8977): Ability to break typesystem with static struct initializer $(LPAREN)e.g. modify immutable$(RPAREN))
$(LI $(BUGZILLA 9017): __traits$(LPAREN)compiles, { enum e = $(LESS)expression tuple$(GREATER); }$(RPAREN) is true but code doesn't compile)
$(LI $(BUGZILLA 9235): Template mixin doesn't allow to mixin non-conflicting overloads)
$(LI $(BUGZILLA 9247): Compiler accepts opaque struct returned by value from function pointer declaration.)
$(LI $(BUGZILLA 9319): Unexpected compiles __traits behaviour in a certain situation)
$(LI $(BUGZILLA 9364): [ICE] Error: CTFE internal error painting S*)
$(LI $(BUGZILLA 9396): Wrong line number when assigning nested enum to struct)
$(LI $(BUGZILLA 9524): Unittest ddocs fail to appear following ditto)
$(LI $(BUGZILLA 9531): __traits$(LPAREN)parent, ...$(RPAREN) does not work for types defined within a unittest block)
$(LI $(BUGZILLA 9534): Distributed CHM file lacks styling)
$(LI $(BUGZILLA 9546): getProtection trait does not work with mixin or getMember)
$(LI $(BUGZILLA 9571): link error due to using unique ids in anonymous funcliteral)
$(LI $(BUGZILLA 9578): "is a nested function and cannot be accessed from" problem)
$(LI $(BUGZILLA 9586): Win64 5/6/7 struct returns)
$(LI $(BUGZILLA 9628): Lambda in foreach loop Vs. lambda in static foreach loop)
$(LI $(BUGZILLA 9634): [CTFE] wrong code concatenating arrays of structs)
$(LI $(BUGZILLA 9665): Structure constant members can not be initialized if have opAssign)
$(LI $(BUGZILLA 9710): Pointer enums crash dmd)
$(LI $(BUGZILLA 9733): Hello world segfaults on Debian x86_64 with -m64)
$(LI $(BUGZILLA 9782): implementing RTInfo!T causes errors for deprecated types)
$(LI $(BUGZILLA 9859): Cannot use inout in delegate)
$(LI $(BUGZILLA 9904): typeof$(LPAREN)null$(RPAREN) can be casted to aggregate type if .sizeof equals size of pointer)
$(LI $(BUGZILLA 9921): Enum variables of type void should be illegal)
$(LI $(BUGZILLA 9923): [ICE] $(LPAREN)interpret.c line 167$(RPAREN) with countUntil on Typedef[])
$(LI $(BUGZILLA 9938): ICE using global interface variable in CTFE)
$(LI $(BUGZILLA 9954): Runtime wrong code with global interface var created in CTFE)
$(LI $(BUGZILLA 9982): ICE on CTFE for pointer dereference)
$(LI $(BUGZILLA 10007): function overrides but is not covariant)
$(LI $(BUGZILLA 10037): Compiler should not generate opEquals method implicitly)
$(LI $(BUGZILLA 10064): opDollar called on garbage)
$(LI $(BUGZILLA 10065): Compiler fails without error message for tuple map)
$(LI $(BUGZILLA 10079): Built-in generated opAssign should be pure nothrow @safe by default)
$(LI $(BUGZILLA 10082): ICE$(LPAREN)e2ir.c$(RPAREN) Multiple mixin template instantiations are not checked)
$(LI $(BUGZILLA 10083): Insufficient IFTI/eponymous template specification)
$(LI $(BUGZILLA 10086): ICE$(LPAREN)glue.c$(RPAREN) or wrong code on passing variable as template value parameter)
$(LI $(BUGZILLA 10094): NRVO with static array return should work)
$(LI $(BUGZILLA 10099): Diagnostic for disabled default construction should improve)
$(LI $(BUGZILLA 10113): Can't use an enum : string in a switch statement)
$(LI $(BUGZILLA 10141): wrong error message with Tuple!$(LPAREN)int$(RPAREN) : Error: static assert  "Cannot put a char[] into a Appender!$(LPAREN)string$(RPAREN)")
$(LI $(BUGZILLA 10156): Can't handle usage of TypeTuple argument in templated function)
$(LI $(BUGZILLA 10196): RDMD: RDMD can't be used from MSys)
$(LI $(BUGZILLA 10198): CTFE: Wrong code for multi-dimensional block assignment)
$(LI $(BUGZILLA 10208): Module-level const/immutable variables with initialization value don't support UDAs)
$(LI $(BUGZILLA 10211): CTFE: Support casts from S** to D**, if S* -> D* is supported.)
$(LI $(BUGZILLA 10214): Incorrect "element-wise assignment is better" warning)
$(LI $(BUGZILLA 10243): [CTFE] Wrong-code on passing dereferenced array pointer by ref)
$(LI $(BUGZILLA 10244): ICE: expression.c:8364: virtual Expression* CallExp::semantic$(LPAREN)Scope*$(RPAREN): Assertion `td` failed)
$(LI $(BUGZILLA 10249): incorrect mangling for overloaded symbol)
$(LI $(BUGZILLA 10252): CTFE: Should generate error for shifts outside valid range)
$(LI $(BUGZILLA 10254): Purity correctness is broken with constructor)
$(LI $(BUGZILLA 10273): ICE$(LPAREN)ctfeexpr.c$(RPAREN): using CTFE after error in struct default values)
$(LI $(BUGZILLA 10274): DMD 2.063 produces broken binaries)
$(LI $(BUGZILLA 10275): CTFE: Allow const casts of struct literals)
$(LI $(BUGZILLA 10277): Incorrect error file and line on redeclaration of TypeInfo)
$(LI $(BUGZILLA 10279): Calling a typesafe variadic @trusted function from an @safe function results in an error.)
$(LI $(BUGZILLA 10280): CTFE: Circular variable initializers should be detected properly)
$(LI $(BUGZILLA 10283): ICE$(LPAREN)interpret.c$(RPAREN): passing struct with failed initalizer to CTFE)
$(LI $(BUGZILLA 10288): Direct lambda call and purity inference bug)
$(LI $(BUGZILLA 10289): compiler should infer nothrow even if Error is thrown)
$(LI $(BUGZILLA 10296): Nested template function call and purity inference bug)
$(LI $(BUGZILLA 10298): CTFE fails with array literal initialization)
$(LI $(BUGZILLA 10302): Package module conflicts with package name)
$(LI $(BUGZILLA 10319): @safe/pure/nothrow error should print fully qualified name)
$(LI $(BUGZILLA 10325): ddoc: template constraints inconsistently shown in generated html)
$(LI $(BUGZILLA 10327): Missing 'package.d' for DIP37 needs a better error message)
$(LI $(BUGZILLA 10341): Range case without an associated switch statement crashes DMD)
$(LI $(BUGZILLA 10343): Cannot resolve a forward reference to a template inside global typeof)
$(LI $(BUGZILLA 10344): Exiting _Dmain should flush all FILE*s and return nonzero on failure)
$(LI $(BUGZILLA 10346): No line number error with undefined template identifier)
$(LI $(BUGZILLA 10354): DIP37: ICE with using indirectly imported template through package.d)
$(LI $(BUGZILLA 10359): Pointer slicing allowed in @safe mode)
$(LI $(BUGZILLA 10381): Nonsense associative array comparison)
$(LI $(BUGZILLA 10386): Package import feature breaks with static libraries)
$(LI $(BUGZILLA 10389): Infinite recursion on printing self-referential StructLiteralExp)
$(LI $(BUGZILLA 10390): ICE on printing ClassReferenceExp)
$(LI $(BUGZILLA 10405): redundant "expression has no effect" error when returning non-void in void function)
$(LI $(BUGZILLA 10414): Delegate arguments for lazy variadic functions are only inferred in first argument)
$(LI $(BUGZILLA 10415): Bad error message with const property of const class instance)
$(LI $(BUGZILLA 10418): bad error message: "not a property")
$(LI $(BUGZILLA 10419): Unhandled exception in dmd after correct error message)
$(LI $(BUGZILLA 10421): 'package' access should work with package module)
$(LI $(BUGZILLA 10429): RDMD: --loop option doesn't work due to symbol conflict)
$(LI $(BUGZILLA 10431): ICE$(LPAREN)DMD 2.063$(RPAREN) in struct.c:741)
$(LI $(BUGZILLA 10432): RDMD: --dry-run option tries to read non-existent file)
$(LI $(BUGZILLA 10433): Array sum operation in function template)
$(LI $(BUGZILLA 10435): rdmd doesn't support the -op argument.)
$(LI $(BUGZILLA 10451): Array of pointers to opaque struct gives forward reference errors.)
$(LI $(BUGZILLA 10452): CTFE: Cannot compare delegates with == or 'is')
$(LI $(BUGZILLA 10462): interface thunk doesn't preserve EBX)
$(LI $(BUGZILLA 10479): cannot pass implicitly to base class casted result to out contract by ref)
$(LI $(BUGZILLA 10495): Incorrect "initializer required" error using lambdas in class with fields with disabled default construction)
$(LI $(BUGZILLA 10497): Opaque structs cannot be dereferenced in pointer to pointer types)
$(LI $(BUGZILLA 10504): Tuple error: no property 'offsetof' for type 'int')
$(LI $(BUGZILLA 10506): Purity should not be checked in a mixin statement)
$(LI $(BUGZILLA 10519): Stray-paren in doc-unittest code generates wrong document)
$(LI $(BUGZILLA 10526): opDispatch with IFTI should not disable UFCS)
$(LI $(BUGZILLA 10534): Addition and subtraction of delegates allowed)
$(LI $(BUGZILLA 10539): [REG][2.063] Implicit pointer to array dereference for .ptr property fails)
$(LI $(BUGZILLA 10542): implicitly generated class ctor doesnt inherit base class ctor attributes)
$(LI $(BUGZILLA 10551): [CTFE] Wrong-code on passing dereferenced array pointer by ref 2)
$(LI $(BUGZILLA 10568): CTFE rejects function pointer safety casts)
$(LI $(BUGZILLA 10583): DMD 2.063 dumps core with mixins involving __traits$(LPAREN)getProtection, ..)
$(LI $(BUGZILLA 10595): Using alias this and a hash generates wrong code)
$(LI $(BUGZILLA 10596): A method with out contract and auto return type causes segfault)
$(LI $(BUGZILLA 10597): opDollar not callable in static constext)
$(LI $(BUGZILLA 10599): CTFE: assert failure interpret.c 310)
$(LI $(BUGZILLA 10609): Refused UFCS in __traits$(LPAREN)compile$(RPAREN))
$(LI $(BUGZILLA 10610): interpret.c:4067 Assertion Failure)
$(LI $(BUGZILLA 10618): Template instance member access disallowed in dynamic array allocation)
$(LI $(BUGZILLA 10630): Structs with disabled default construction can't be used as `out` parameters)
$(LI $(BUGZILLA 10633): Win64: wrong codegen with %=)
$(LI $(BUGZILLA 10634): Win64: wrong codegen with .init of small structs)
$(LI $(BUGZILLA 10639): Win64: wrong optimizer codegen with struct literal with complex fields)
$(LI $(BUGZILLA 10642): Win64: wrong codegen comparing different sized integer arguments)
$(LI $(BUGZILLA 10646): No front-end error for invalid casting dynamic array/static array to class reference)
$(LI $(BUGZILLA 10651): Throwing non-Throwable object causes ICE)
$(LI $(BUGZILLA 10676): excessive compilation times with optimized PIC build)
$(LI $(BUGZILLA 10677): Win64: cfloat return value not forwarded correctly as function argument)
$(LI $(BUGZILLA 10678): Win64: wrong code passing small fixed sized array as function argument)
$(LI $(BUGZILLA 10694): wrong purity check for static variables with impure destructor)
$(LI $(BUGZILLA 10695): __MODULE__ in string mixin crashes compiler)
$(LI $(BUGZILLA 10715): negated bit test $(LPAREN)bt$(RPAREN) not recognized by optimizer)
$(LI $(BUGZILLA 10735): Buffer overflow bug in symbol_generate$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 10746): Win64: corrupt debug info with very long symbols)
$(LI $(BUGZILLA 10752): accessing a private cached symbol a second time doesn't cause an error in __traits$(LPAREN)compiles, ...$(RPAREN))
$(LI $(BUGZILLA 10758): Unsound type checking for inout.)
$(LI $(BUGZILLA 10761): DMD crashes on unspecified inout matching.)
$(LI $(BUGZILLA 10768): DMD does not show deprecation message for missing 'override' keyword)
$(LI $(BUGZILLA 10781): ctRegex! throws a huge error)
$(LI $(BUGZILLA 10783): ICE and bad diagnostics when using non-existent symbols in switch and with statements)
$(LI $(BUGZILLA 10792): Bad diagnostic on new eponymous enum template syntax)
$(LI $(BUGZILLA 10793): Forward reference errors casting from void* to opaque struct pointer)
$(LI $(BUGZILLA 10809): [REG] darwin 32 dmd release broken)
$(LI $(BUGZILLA 10811): Order dependent IFTI failure)
$(LI $(BUGZILLA 10813): ICE$(LPAREN)DMD2.063$(RPAREN) template.c:6040: Identifier* TemplateInstance::genIdent$(LPAREN)Objects*$(RPAREN): Assertion `global.errors` failed)
$(LI $(BUGZILLA 10834): cannot use cast$(LPAREN)void$(RPAREN)expr if the type of expr is a struct)
$(LI $(BUGZILLA 10840): [CTFE] *this._data.arr is not yet implemented at compile time)
$(LI $(BUGZILLA 10842): Some integer casts wrongly remove side-effect of the operand.)
$(LI $(BUGZILLA 10857): ICE$(LPAREN)glue.c,　bugzilla 2962?$(RPAREN) or compiles, depending on the files order)
$(LI $(BUGZILLA 10858): CTFE wrong code for comparison of array of pointers)
$(LI $(BUGZILLA 10862): Assignment inside if condition still sometimes accepted)
$(LI $(BUGZILLA 10869): Ddoc mark methods with "const" twice)
$(LI $(BUGZILLA 10870): Ddoc adds "abstract" to interfaces)
$(LI $(BUGZILLA 10937): struct inside union gives uninitialized error in CTFE)
$(LI $(BUGZILLA 10942): ICE on 1087+ initializers $(LPAREN)Internal error: backend\cgcv.c 203$(RPAREN))
$(LI $(BUGZILLA 10944): [ICE]$(LPAREN)interpret.c line 310$(RPAREN) with arith operation on missing variable)
$(LI $(BUGZILLA 10947): const out parameter is not properly rejected)
$(LI $(BUGZILLA 10953): Attribute inheritance needs to apply to contracts, too)
$(LI $(BUGZILLA 10968): array element copy $(LPAREN)1-N and N-N$(RPAREN) ignores postblit attributes)
$(LI $(BUGZILLA 10969): Variadic template parameter re-use in function signature)
$(LI $(BUGZILLA 10970): Segfault in a simple test compiled without -g.)
$(LI $(BUGZILLA 10980): static initialization of immutable structs with disabled postblit fails)
$(LI $(BUGZILLA 10984): Frame access diagnostic should improve)
$(LI $(BUGZILLA 10989): [CTFE] Uncaught exception messages are not pretty printed if message wasn't literal)
$(LI $(BUGZILLA 10990): Passing in a module as a mixin to __traits$(LPAREN)getUnitTests$(RPAREN) behaves differently than passing in the module directly.)
$(LI $(BUGZILLA 10992): Trait getUnitTests skips first test if aggregate contains multiple tests.)
$(LI $(BUGZILLA 10993): mangling of voldemort types with lambdas changes during return type inference)
$(LI $(BUGZILLA 10995): CTFE failures for structs with void initialized members)
$(LI $(BUGZILLA 11002): Compiler doesn't see std.sys.linux.epoll.)
$(LI $(BUGZILLA 11075): ICE$(LPAREN)struct.c$(RPAREN) after gagged error in struct field initializer)
$(LI $(BUGZILLA 11125): UFCS instantiation of template causes template constraint to be skipped)
$(LI $(BUGZILLA 11132): Odd diagnostic with C-style struct initializer when union field is present)
$(LI $(BUGZILLA 11134): Inconsistent postblit call count depends on the pointer size)
$(LI $(BUGZILLA 11136): ICE on incorrect module declaration)
$(LI $(BUGZILLA 11137): Stack overflow on invalid output path)
$(LI $(BUGZILLA 11141): Missing .pdb file with phobos64)
$(LI $(BUGZILLA 11142): Wrong error message "no size yet for forward reference" for opaque struct)
$(LI $(BUGZILLA 11144): Better diagnostic for typeid symbol)
$(LI $(BUGZILLA 11145): Duplicated deprecation message "use of typedef is deprecated;")
$(LI $(BUGZILLA 11146): Wrong line number of "identity assignment operator overload is illegal")
$(LI $(BUGZILLA 11147): Nested structs in a union are not correctly initialized)
$(LI $(BUGZILLA 11151): Undetected overlapping initialization)
$(LI $(BUGZILLA 11159): [CTFE] Integer exponentiation give incorrect values)
$(LI $(BUGZILLA 11164): wrong dependencies generated when compiling with -main)
$(LI $(BUGZILLA 11182): dmd crashes on compiling regex)
$(LI $(BUGZILLA 11187): A small transitive const bug on struct copying)
)
)

$(BUGSTITLE DMD Compiler enhancements,

$(P
$(LI $(BUGZILLA 658): struct pointers in with$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 767): compiler shall print dependencies and pragma$(LPAREN)lib$(RPAREN))
$(LI $(BUGZILLA 5943): Power expression optimisation for 2^^unsigned)
$(LI $(BUGZILLA 8635): Allow postfix expressions for new)
$(LI $(BUGZILLA 9022): IFTI should support enclosing type/scope deduction)
$(LI $(BUGZILLA 9097): Value range propagation to disable some array bound tests)
$(LI $(BUGZILLA 9565): Index of static array should not print literal suffix)
$(LI $(BUGZILLA 10022): Importing packages)
$(LI $(BUGZILLA 10117): Support C++ class-scope static variables)
$(LI $(BUGZILLA 10236): Ddoc: Warning on wrong parameter names)
$(LI $(BUGZILLA 10334): ddoc should prefer simple syntax for template instantiations with one parameter)
$(LI $(BUGZILLA 10367): DDoc should output enum base type)
$(LI $(BUGZILLA 10688): Misleading error message when attempting a "private override")
$(LI $(BUGZILLA 10724): Allow slice of string literal to convert to const$(LPAREN)char$(RPAREN)*)
$(LI $(BUGZILLA 10991): Implement trait to get vptr index of a method.)
$(LI $(BUGZILLA 11088): Diagnostics for enum member overflows should improve)
$(LI $(BUGZILLA 11257): Allow whole implicit conversion if one or more overlapped field could.)
)
)

$(BUGSTITLE Phobos regressions,

$(P
$(LI $(BUGZILLA 10218): std.typecons.opAssign is not CTFEable)
$(LI $(BUGZILLA 10268): [REG2.063] std.typecons.Nullable!JSONValue - error instantiating)
$(LI $(BUGZILLA 10355): fullyQualifiedName doesn't work with enums)
$(LI $(BUGZILLA 10468): Regression $(LPAREN)2.063$(RPAREN): Lockstep no longer works with iota)
$(LI $(BUGZILLA 10499): [REG 2.064] retro is no longer CTFE-able)
$(LI $(BUGZILLA 10686): No [] operator overload for immutable Tuple)
$(LI $(BUGZILLA 10866): Regression $(LPAREN)2.064 git-head$(RPAREN) Massive compiler slowdown)
$(LI $(BUGZILLA 10896): currently tools/ddemangle doesn't compile on git master)
$(LI $(BUGZILLA 10906): [2.064 git-head] Out of memory compiling Phobos on Windows)
$(LI $(BUGZILLA 10913): [2.064 git-head] regex/demange compilation failure)
$(LI $(BUGZILLA 11009): Regression $(LPAREN)2.064 git-head$(RPAREN): DMD consumes huge memory when it compiles enum containing many items)
$(LI $(BUGZILLA 11057): [REG2.064dev] New std.uni has icmp$(LPAREN)$(RPAREN) partly broken)
$(LI $(BUGZILLA 11165): std.typecons._d_toObject conflicts with std.signals._d_toObject)
$(LI $(BUGZILLA 11283): [REG 2.064] assert in std/windows/syserror.d)
)
)

$(BUGSTITLE Phobos bugs,

$(P
$(LI $(BUGZILLA 2717): alloca$(LPAREN)0$(RPAREN) leaves stack unaligned on OSX)
$(LI $(BUGZILLA 4575): Uses of deprecated delete statement in D2 Phobos)
$(LI $(BUGZILLA 5224): std.algorithm.remove!$(LPAREN)SwapStrategy.unstable$(RPAREN) doesn't work)
$(LI $(BUGZILLA 5378): File.byLine terminator string)
$(LI $(BUGZILLA 5630): array$(LPAREN)$(RPAREN) of iterable of immutable items)
$(LI $(BUGZILLA 5692): Printing complex numbers with negative imaginary part)
$(LI $(BUGZILLA 5942): Bitfields are overwritten erroneously)
$(LI $(BUGZILLA 6342): Tuple field access problem in pure function)
$(LI $(BUGZILLA 6407): take$(LPAREN)map$(RPAREN) problem)
$(LI $(BUGZILLA 6686): bitmanip bitfields are broken at 64 bits)
$(LI $(BUGZILLA 6893): Write of enum member represented with ubyte or ulong)
$(LI $(BUGZILLA 7756): iota$(LPAREN)const doubles$(RPAREN) problem)
$(LI $(BUGZILLA 8124): std.net.isemail not included in phobos.lib)
$(LI $(BUGZILLA 8330): std.algorithm.find doesn't handle reference type ranges correctly)
$(LI $(BUGZILLA 8474): bitfields doesn't work with 32 bit fields)
$(LI $(BUGZILLA 8806): fullyQualifiedName!T does not work for inner types)
$(LI $(BUGZILLA 9310): escapeShellCommand unittests are never run)
$(LI $(BUGZILLA 9384): std.socket: UnixAddress broken on Linux and others)
$(LI $(BUGZILLA 9548): BigInt: Wrong comparison result: BigInt$(LPAREN)"-1"$(RPAREN) > long.min)
$(LI $(BUGZILLA 9557): std.array.array of array of immutable structs)
$(LI $(BUGZILLA 9559): Range of Nullable doesn't work with std.array.array)
$(LI $(BUGZILLA 9579): std.regex.replace format argument should not require same constness as target string)
$(LI $(BUGZILLA 9599): File.byLine doesn't function properly with take)
$(LI $(BUGZILLA 9607): std.random.randomShuffle and partialShuffle don't work with Xorshift)
$(LI $(BUGZILLA 9629): toUpperInPlace doesn't work properly with unicode characters)
$(LI $(BUGZILLA 9725): std.string.format does wasteful UTF decoding)
$(LI $(BUGZILLA 9824): Emplace is broken)
$(LI $(BUGZILLA 9967): ParameterIdentifierTuple broken for setters)
$(LI $(BUGZILLA 10017): Can not assign to a Variant another Variant holding a bigger structure)
$(LI $(BUGZILLA 10078): std.string.indexOf$(LPAREN)Char[], dchar, CaseSensitive$(RPAREN) fails at compile time)
$(LI $(BUGZILLA 10130): map of iota with const step)
$(LI $(BUGZILLA 10161): std.datetime unittest failure "Libya Standard Time")
$(LI $(BUGZILLA 10188): Wrong Document Comment on std.format.d$(LPAREN)176$(RPAREN))
$(LI $(BUGZILLA 10216): Bad warning in std.process.kill)
$(LI $(BUGZILLA 10265): RandomSample fails when passed an InputRange as input)
$(LI $(BUGZILLA 10269): RandomSample should use popFrontExactly, not popFrontN, when skipping across input range)
$(LI $(BUGZILLA 10322): std.random.RandomSample.index$(LPAREN)$(RPAREN) returns wrong value if called before front$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 10347): buildPath returns relative path when joining absolute with relative path)
$(LI $(BUGZILLA 10348): isRooted is either wrong or poorly specified)
$(LI $(BUGZILLA 10377): std.typecons.wrap doesn't consider private members)
$(LI $(BUGZILLA 10408): Two-function std.algorithm.reduce of a const array)
$(LI $(BUGZILLA 10426): Improve code coverage of std.random unittests)
$(LI $(BUGZILLA 10463): dirEntries$(LPAREN)$(RPAREN) segfaults on paths the user does not have access to)
$(LI $(BUGZILLA 10469): WinAPI declarations in std.process should be moved to core.sys.windows.windows)
$(LI $(BUGZILLA 10474): When takeExactly returns a new range type, it fails to propagate all relevant attributes)
$(LI $(BUGZILLA 10510): enforce can't take an extern$(LPAREN)C$(RPAREN) function to call)
$(LI $(BUGZILLA 10517): readln$(LPAREN)Char$(RPAREN)$(LPAREN)Char[] buf$(RPAREN) accepts non-mutable buffers)
$(LI $(BUGZILLA 10536): std.typecons.wrap doesn't work with a class that defines opCast)
$(LI $(BUGZILLA 10543): std.algorithm.map incorrectly uses source range length for narrow strings)
$(LI $(BUGZILLA 10550): Xorshift32 and Xorshift160 do not generate uniformly-distributed random numbers)
$(LI $(BUGZILLA 10570): Example of `how` function for AutoImplement should work for non-abstract class)
$(LI $(BUGZILLA 10601): std.path.setExtension leaves trailing dot if extension is empty)
$(LI $(BUGZILLA 10607): DirEntry has no constructor)
$(LI $(BUGZILLA 10608): std.typecons.RefCounted has very poor diagnostics)
$(LI $(BUGZILLA 10644): Win64: wrong code when passing arguments through ...)
$(LI $(BUGZILLA 10647): AutoImplement should implement overridden member functions with 'override' attributes)
$(LI $(BUGZILLA 10660): ddoc on std.algorithm: Cheat sheet description for 'filter' is wrong)
$(LI $(BUGZILLA 10680): BigInt uses deprecated std.traits.unsigned)
$(LI $(BUGZILLA 10732): Example code for std.utf.toUTFindex does not work)
$(LI $(BUGZILLA 10773): std.algorithm.splitter produces infinite range with empty delimiter)
$(LI $(BUGZILLA 10796): std.regex: ctRegex bug with '.' and $ in multi-line mode)
$(LI $(BUGZILLA 10797): std.regex: ctRegex "codegen" bug with certain nested infinite loops)
$(LI $(BUGZILLA 10799): std.regex: ctRegex lookahead support)
$(LI $(BUGZILLA 10800): ParameterDefaultValueTuple returns an empty string for default values in property functions.)
$(LI $(BUGZILLA 10801): std.regex: support for lookbehind in ctRegex)
$(LI $(BUGZILLA 10802): std.regex: ctRegex fails to compile with backreference)
$(LI $(BUGZILLA 10874): std.conv.to should support conversion from ulong to int-based enum)
$(LI $(BUGZILLA 10893): Numerous DDoc parameter warnings in Phobos $(LPAREN)as found by 10236$(RPAREN))
$(LI $(BUGZILLA 10898): LockingTextWriter segfaults in .init state)
$(LI $(BUGZILLA 10951): EnumMembers should document about returning duplicate members)
$(LI $(BUGZILLA 11068): raw formatting of chars and strings is wrong)
$(LI $(BUGZILLA 11089): std.string.toUpper doesn't work with 1:m mappings)
$(LI $(BUGZILLA 11152): formatChar doesn't handle `\0`)
$(LI $(BUGZILLA 11160): Bitfield compilation error with degenerate bitfields of length 32 & 64)
$(LI $(BUGZILLA 11194): std.container.Array.reserve calls opAssign on uninitialized data)
$(LI $(BUGZILLA 11222): std.string.isNumeric accepts a "+")
$(LI $(BUGZILLA 11232): Windows sysErrorString only supports ASCII)
)
)

$(BUGSTITLE Phobos enhancements,

$(P
$(LI $(BUGZILLA 4120): bigint implicit cast too bool)
$(LI $(BUGZILLA 4124): toString$(LPAREN)$(RPAREN) for BitArray)
$(LI $(BUGZILLA 4850): std.conv.to isn't pure)
$(LI $(BUGZILLA 6154): std.math.abs on std.complex numbers too)
$(LI $(BUGZILLA 6381): math.floor, math.ceil are not pure functions.)
$(LI $(BUGZILLA 6626): std.complex.expi$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 9699): strip functions should have stripLeft/stripRight counterparts and be generic)
$(LI $(BUGZILLA 10092): Renaming std.range.chunks as std.range.chunked)
$(LI $(BUGZILLA 10314): Add std.traits.signed)
$(LI $(BUGZILLA 10538): std.typecons.wrap should consider opDispatch)
$(LI $(BUGZILLA 10621): dirEntry is $(LPAREN)now$(RPAREN) useless)
$(LI $(BUGZILLA 10717): std.ascii.toLower and toUpper should return char instead of dchar and avoid me to use a bad cast$(LPAREN)char$(RPAREN))
$(LI $(BUGZILLA 10868): std.string.translate should take an optional buffer)
$(LI $(BUGZILLA 10881): Support %f formatting for a std.complex.complex)
$(LI $(BUGZILLA 10909): std.conv.to!$(LPAREN)bool$(RPAREN)$(LPAREN)int$(RPAREN): conversion from integer to bool)
$(LI $(BUGZILLA 11020): Add function for getting the current executable path)
$(LI $(BUGZILLA 11123): std.getopt should support functions)
)
)

$(BUGSTITLE Druntime regressions,

$(P
$(LI $(BUGZILLA 10976): thread_joinAll after main exit performed too late)
)
)

$(BUGSTITLE Druntime bugs,

$(P
$(LI $(BUGZILLA 6210): Associative array with array key often cannot be equated.)
$(LI $(BUGZILLA 6372): data loss due to possible bug in garbage collector)
$(LI $(BUGZILLA 7741): getHash inconsistent for const$(LPAREN)char$(RPAREN)[] vs. char[] and string)
$(LI $(BUGZILLA 8435): BigInts don't work well in associative arrays)
$(LI $(BUGZILLA 9783): profiling recursive function calls yields bad tree timing)
$(LI $(BUGZILLA 9852): Empty associative array crashes program)
$(LI $(BUGZILLA 10027): demangled name format of local function is wrong)
$(LI $(BUGZILLA 10118): BigInt as associative array key wrong behavior)
$(LI $(BUGZILLA 10323): getAMDcacheinfo needlessly allocates)
$(LI $(BUGZILLA 10420): Incorrect function attributes in `core.exception`)
$(LI $(BUGZILLA 10436): The runtime should print stack traces to stderr $(LPAREN)like on *nix$(RPAREN), not stdout)
$(LI $(BUGZILLA 10457): _d_toObject might fail with shared libraries)
$(LI $(BUGZILLA 10593): array's reserve/capacity go haywire if length has been changed prior)
$(LI $(BUGZILLA 10711): shared phobos library should not depend on _Dmain)
$(LI $(BUGZILLA 10720): ICE with is$(LPAREN)aaOfNonCopyableStruct.nonExistingField$(RPAREN))
$(LI $(BUGZILLA 10894): Numerous DDoc parameter warnings in druntime $(LPAREN)as found by 10236$(RPAREN))
)
)

$(BUGSTITLE Druntime enhancements,

$(P
$(LI $(BUGZILLA 9190): Vector operations are not optimized for x86_64 architecture)
)
)

$(BUGSTITLE Installer bugs,

$(P
$(LI $(BUGZILLA 10062): installers should use CDN)
)
)

$(BUGSTITLE Website bugs,

$(P
$(LI $(BUGZILLA 9533): CHM generation crashes)
$(LI $(BUGZILLA 10031): Link to old wiki on dlang.org)
$(LI $(BUGZILLA 10230): Duplicated buttons for runnable examples)
$(LI $(BUGZILLA 10410): Improve cast$(LPAREN)void$(RPAREN) documentation)
$(LI $(BUGZILLA 10461): Incorrect example of "depend on order of evaluation" expression)
$(LI $(BUGZILLA 10565): Level-5 titles are missing in Language reference)
$(LI $(BUGZILLA 10605): Lambda grammar is not sufficient)
$(LI $(BUGZILLA 10885): [std.range] refRange is missing from module description tables)
$(LI $(BUGZILLA 11001): Need documentation for __traits$(LPAREN)getVirtualIndex$(RPAREN))
$(LI $(BUGZILLA 11036): Document that .stringof should not be used for code generation)
)
)

)

$(COMMENT $(UPCOMING
	$(LI Shared libraries for Linux)
))

$(VERSION 063, May 28, 2013, =================================================,

$(BUGSTITLE Language Changes,
$(LI $(RELATIVE_LINK2 staticfields, Const and immutable fields with initializers are now warned about.))
$(LI $(RELATIVE_LINK2 ctorqualifier, Constructor qualifiers are taken into account when constructing objects.))
$(LI $(RELATIVE_LINK2 structuralcompare, Struct members which require non-bitwise comparison are now properly compared.))
$(LI $(RELATIVE_LINK2 slicecopy, Array copy operations now always require using the slice syntax.))
$(LI $(RELATIVE_LINK2 passtype, Types no longer act as arguments in typeof expressions.))
$(LI $(RELATIVE_LINK2 foreachref, The index variable in a foreach range is no longer implicitly a reference.))
$(LI $(RELATIVE_LINK2 hashentry, Associative array entries are no longer default-initialized before assignment.))
$(LI $(RELATIVE_LINK2 constinherit, The const attribute is no longer inherited in overriden methods.))
$(LI $(RELATIVE_LINK2 typeofnullconv, typeof(null) no longer implicitly converts to T[].))
$(LI $(RELATIVE_LINK2 templatethisattrib, The Template This Parameter now changes the member function qualifier.))
$(LI $(RELATIVE_LINK2 sliceref, Array slices are now r-values.))
$(LI $(RELATIVE_LINK2 thisrefaccess, Accessing a non-static field without a $(D this) reference is only allowed in certain contexts.))
$(LI $(RELATIVE_LINK2 implicitarrayptr, Arrays no longer implicitly convert to a pointer.))
)

$(BUGSTITLE Language Enhancements,
$(LI $(RELATIVE_LINK2 uniqueinference, Expressions which return unique objects can be implicitly casted to immutable.))
$(LI $(RELATIVE_LINK2 staticarrayvoid, Static array of void can now be user-initialized.))
$(LI $(RELATIVE_LINK2 multiinvariant, Aggregates can now contain multiple invariants.))
$(LI $(RELATIVE_LINK2 attribinference, Methods of templated aggregates can now infer attributes.))
$(LI $(RELATIVE_LINK2 isexpident, $(B is expression) no longer requires an identifier.))
$(LI $(RELATIVE_LINK2 implicitarraycast, Dynamic arrays of known size can be implicitly cast to static arrays in some contexts.))
$(LI $(RELATIVE_LINK2 tupleinitvoid, Tuples can now be void-initialized.))
$(LI $(RELATIVE_LINK2 tupleequality, Tuples can now be compared for equality.))
$(LI $(RELATIVE_LINK2 templconstraint, Template constraints can now be put after the inheritance list.))
$(LI $(RELATIVE_LINK2 initfield, Fields with initializers can now be re-initialized in a const constructor.))
$(LI $(RELATIVE_LINK2 isnestedtrait, Added the $(B isNested) trait for discovery of aggregates and functions with context pointers.))
$(LI $(RELATIVE_LINK2 nestedtemplate, Templates can now be nested inside of functions.))
$(LI $(RELATIVE_LINK2 ufcslocalimport, UFCS now works with scoped local imports.))
$(LI $(RELATIVE_LINK2 prettyfunc, Added $(D __FUNCTION__), $(D __PRETTY_FUNCTION__) and $(D __MODULE__).))
$(LI $(RELATIVE_LINK2 deprecatedmacro, DDoc: Deprecated declarations are now wrapped in a $(B DEPRECATED) macro.))
$(LI $(RELATIVE_LINK2 documentedunittest, Added documented unittest feature for verifiable code example generation.))
)

$(BUGSTITLE Compiler Enhancements,
$(LI $(RELATIVE_LINK2 mainswitch, Added -main switch which adds an empty main function.))
$(LI $(RELATIVE_LINK2 minimalcov, Added -cov=percentage switch for minimal coverage tests.))
$(LI $(RELATIVE_LINK2 symbolmangle, Added ability to override the mangling of a symbol with a compiler pragma.))
)

$(BUGSTITLE Phobos Changes,
$(LI $(RELATIVE_LINK2 scopedtypeof, std.typecons.scoped implementation changed, potentially breaking some user-code.))
)

$(BUGSTITLE Phobos Enhancements,
$(LI $(RELATIVE_LINK2 newstdprocess, std.process has been redesigned from the ground up and introduces a new API and functionality.))
$(LI $(RELATIVE_LINK2 getoptbool, std.getopt can now set booleans to false.))
$(LI $(RELATIVE_LINK2 ownertid, Added ownerTid property in std.concurrency.))
)

$(BR)$(BIG $(RELATIVE_LINK2 list2063, List of all bug fixes and enhancements in D 2.063.))

$(HR)

$(BUGSTITLE Language Changes,

$(LI $(LNAME2 staticfields, Const and immutable fields with initializers are now warned about:)

$(P Eventually, they will be deprecated, and then will trigger an error. Such fields should now
be changed to enum or static.)

$(P In a future release, a new behavior for them will be enabled:)

$(P Fields in an aggregate which are not static will always be addressable.
This means they will occupy space in the object:)

---------
struct S
{
    // used to be implicitly static in 2.062, now warns. In a future release it will become non-static.
    immutable int[] arr = [1, 2];

    // ditto
    const int[] arr2 = [1, 2];
}
---------

$(P This means that code which accessed such declarations without the $(D this)
reference will no longer compile. Additionally code which depended on the size
of a structure with such fields will have to be fixed:)

---------
struct S
{
    immutable int[] arr = [1, 2];
}

void main()
{
    auto x = S.arr;  // becomes an error in a future release, 'arr' will require the 'this' reference.

    // S is size 1 in 2.062 and 2.063. In a future release this will change and the following static assert will pass.
    static assert(S.sizeof == size_t.sizeof + size_t.sizeof);  // ptr + length for the array
}
---------

$(P To make the field static again, simply use the static keyword. Alternatively
make the field an $(D enum) to turn it into a manifest constant:)

---------
struct S
{
    static immutable int[] arr = [1, 2];
    enum arr2 = [1, 2];
}
---------

$(P Note however that manifest constants which are arrays are allocated on each usage,
so you may prefer using $(D static) instead.)

$(H3 Rationale:)

$(P Making a field implicitly static based on whether it is const/immutable and has an initializer leads to confusion. The $(D static) keyword can be used to explicitly make any field static.))

$(LI $(LNAME2 ctorqualifier, Constructor qualifiers are taken into account when constructing objects:)

$(P A qualified constructor is now invoked when a $(D const)/$(D immutable)/$(D shared) aggregate object is
    instantiated, respectively:)

---------
import std.stdio;

class C
{
    this()           { writeln("1"); }
    this() const     { writeln("2"); }
    this() immutable { writeln("3"); }
    this() shared    { writeln("4"); }
}

void main()
{
    auto a = new C;           // writes "1"
    auto b = new const C;     // writes "2"
    auto c = new immutable C; // writes "3"
    auto d = new shared C;    // writes "4"
}
---------


$(P This has the consequence that aggregates which have only $(D immutable) or $(D shared)
    constructors can no longer be used to instantiate mutable objects:)

---------
class C
{
    this() immutable { }
    this() shared { }
}

void main()
{
    auto c1 = new C;           // disallowed
    auto c2 = new immutable C; // ok
    auto c3 = new shared C;    // ok
}
---------

$(P On the other hand, aggregates which do not have $(D shared) or $(D immutable) constructors can
    no longer be used to construct $(D shared) or $(D immutable) objects, respectively:)

---------
class C
{
    this() { }
}

void main()
{
    auto c1 = new C;           // ok
    auto c2 = new immutable C; // disallowed
    auto c3 = new shared C;    // disallowed
}
---------

$(P However, if an aggregate has a $(D pure) constructor it can be used to construct an object with any type constructor:)

---------
class C
{
    this() pure { }
}

void main()
{
    auto c1 = new C;  // ok
    auto c2 = new immutable C;  // ok
    auto c3 = new shared C;  // ok
}
---------
)
$(LI $(LNAME2 structuralcompare, Struct members which require non-bitwise comparison are now properly compared.)

$(P In earlier releases some struct members such as arrays would be bitwise-compared in a comparison operation.
    This has now been changed to be a structural comparison instead:)

---------
struct S
{
    char[] data;
}

void main ()
{
    auto s1 = S("foo".dup);
    auto s2 = S("foo".dup);

    assert(s1.data !is s2.data);  // both are unique data

    assert(s1 == s2);   // passes in 2.063
    assert(s1.data == s2.data);  // equivalent of above
}
---------

$(P If an $(D opEquals) function is not present the compiler rewrites the expression
    $(CODE s1 == s2) to $(CODE s1.tupleof == s2.tupleof). Comparing $(D .tupleof) expressions is
    also a feature new to D in the 2.063 release.))

$(LI $(LNAME2 slicecopy, Array copy operations now always require using the slice syntax:)

$(P The right-hand-side of an array copy operation now requires using the slice syntax:)

---------
void main()
{
    int[][2] x;
    int[] y;
    int[] z;

    x[] = z;    // copies z (pointer + length) 2 times to x
    y[] = z;    // copies each element of z into y (compiler emits warning)
}
---------

$(P If the user intended to write such code they must use the slice syntax for both the source and target arrays:)

---------
void main()
{
    int[][2] x;
    int[] y;
    int[] z;

    y[] = z[];  // copies each element of z into y (no warnings)
}
---------

$(H3 Rationale:)

$(P The compiler will emit a warning to make the user aware that the copy operation is arbitrarily expensive.))

$(LI $(LNAME2 passtype, Types no longer act as arguments in $(D typeof) expressions:)

$(P A type can no longer be passed to a function as a value of that type:)

---------
T[] foo(T)(T t)
{
    return null;
}

void main()
{
    alias int Int;

    // used to work (only with an alias), now a compiler error
    alias typeof(foo(Int)) IntArray;
}
---------

$(P If the user wants to pass an argument of a certain type, they can use the $(D .init) property:)

---------
T[] foo(T)(T t)
{
    return null;
}

void main()
{
    alias typeof(foo(int.init)) IntArray;  // ok
}
---------

$(H3 Rationale:)

$(P Treating types as expressions in special contexts only leads to confusion.
Instead, the $(D .init) property can be used for such purposes.))

$(LI $(LNAME2 foreachref, The index variable in a foreach range is no longer implicitly a reference:)

$(P The index variable in a foreach range is now by default a value type:)

---------
void main()
{
    size_t count;
    foreach (n; 0 .. 10)
    {
        ++n;
        ++count;
    }
    assert(count == 10);  // passes
}
---------

$(P If the user wants to modify the index variable he must use the $(D ref) keyword:)

---------
void main()
{
    size_t count;
    foreach (ref n; 0 .. 10)
    {
        ++n;
        ++count;
    }
    assert(count == 5);
}
---------


$(H3 Rationale:)

$(P Making the index variable implicitly $(D ref) can introduce bugs that are hard to track down.))

$(LI $(LNAME2 hashentry, Associative array entries are no longer default-initialized before assignment:)

$(P An associative array entry used to be default-initialized before assignment took place:)

---------
void main()
{
    int[int] aa;
    aa[1] = aa[1] + 1;   // no Error thrown in 2.062
    assert(aa[1] == 1);  // worked in 2.062
}
---------

$(P In 2.063, accessing an entry which does not exist will now throw a RangeError:)

---------
void main()
{
    int[int] aa;
    aa[1] = aa[1] + 1;   // RangeError thrown in 2.063
}
---------

$(H3 Rationale:)

$(P Default-initialization during assignment can be a source of bugs.))

$(LI $(LNAME2 constinherit, The const attribute is no longer inherited in overriden methods.)

$(P Method overrides no longer inherit constness of the base method:)

---------
class A
{
    void foo() const { }
}

class B : A
{
    // used to work in 2.062, now an error
    override void foo() { }  // note missing 'const'
}
---------

$(P If the user wants to override a const method he has to mark the overriden
    method as const:)

---------
class A
{
    void foo() const { }
}

class B : A
{
    override void foo() const { }  // ok
}
---------

$(P The feature allows introducing new overloads based on the constness of the method:)

---------
class A
{
    void foo() const { }
}

class B : A
{
    // introduces new overload (not override!)
    void foo() { }

    // if the above overload is introduced the user must either:
    // a: re-introduce the const overload to prevent function hijacking
    alias super.foo foo;  // without this you will get a compiler error

    // or b: provide a properly typed override:
    override void foo() const { }
}
---------
)

$(LI $(LNAME2 typeofnullconv, $(D typeof(null)) no longer implicitly converts to T[]:)

$(P The following code used to be allowed:)

---------
void f(int[] function() del)
{
    assert(!del());  // fails
}

typeof(null) g() { return null; }

void main()
{
    f(&g);
    f(() => null);
}
---------

$(P However the implicit conversion would end up generating wrong code.
    To work around this, make sure the return type is typed properly,
    or use $(CODE (T[]).init) in the return expression of a lambda expression:)

---------
void f(int[] function() del)
{
    assert(!del());  // passes
}

int[] g() { return null; }  // fixed return type

void main()
{
    f(&g);  // ok
    f(() => (int[]).init);  // ok
}
---------
)
$(LI $(LNAME2 templatethisattrib, The Template This Parameter now changes the member function qualifier:)

$(P The $(LINK2 template.html#TemplateThisParameter, Template This Parameter) can now be used to infer
the qualifier of $(D this) to member functions:)

---------
struct S
{
    void foo(this T)()
    {
    }
}

void main()
{
     immutable S s;
     s.foo();  // makes S.foo immutable
}
---------
)
$(LI $(LNAME2 sliceref, Array slices are now r-values:)

$(P Array slices are no longer l-values. This means an address can no longer be
taken of a slice, and slices cannot be passed by ref to functions:)

---------
void foo(ref int[] arr) { arr = new int[10]; }

void main()
{
    int[] arr;
    foo(arr);  // ok
    assert(arr.length == 10);

    foo(arr[]);  // disallowed in 2.063, the slice is an r-value
    auto ptr = &arr[1..2];  // disallowed in 2.063, cannot take address of r-value
}
---------

$(P To work around this you can make your function take an r-value if it doesn't
    need to reassign and resize the slice, but only needs to read or modify its contents.
    Otherwise, to accept both l-values and r-values you can make your function take
    its argument by $(D auto ref):)

---------
void take(int[] arr) { }
void takeRef(ref int[] arr) { }
void takeAutoRef(T)(auto ref T[] arr) { }

void main()
{
    int[] arr = [1, 2, 3, 4];
    take(arr);          // ok
    takeRef(arr);       // ok
    takeAutoRef(arr);   // ok

    int[] arr2 = arr[1 .. 2];
    take(arr2);         // ok, arr2 is a variable
    takeRef(arr2);      // ditto
    takeAutoRef(arr2);  // ditto

    take(arr[1 .. 2]);         // ok
    takeRef(arr[1 .. 2]);      // error, cannot pass r-value by reference
    takeAutoRef(arr[1 .. 2]);  // ok
}
---------

$(H3 Rationale:)

$(P Passing slices by reference had no observable effect when reassigning or
resizing such a slice at the call site, therefore such slices should by default be r-values.
For example, the following code used to be allowed but is now a compile-time error:)

---------
void reAssign(ref int[] arr) { arr = new int[2]; }
void reSize(ref int[] arr)   { arr.length = 10; }

void main()
{
    int[] arr = [1, 2, 3, 4];

    reAssign(arr[0 .. 4]);  // reassigning has no observable effect at the call site
    assert(arr == [1, 2, 3, 4]);

    reSize(arr[0 .. 4]);    // resizing has no observable effect at the call site
    assert(arr.length == 4);
}
---------
)
$(LI $(LNAME2 thisrefaccess, Accessing a non-static field without a $(D this) reference is only allowed in certain contexts:)

$(P Accessing non-static fields used to be allowed in many contexts, but is now limited to only a few:)

$(P - $(D offsetof), $(D init), and other built-in properties are allowed:)

---------
struct S { int field; }

void main()
{
    auto a = S.field.offsetof;  // ok, statically known
    auto c = S.field.max;       // ditto
    auto d = S.field;           // disallowed, no `this` reference
}
---------

$(P - When invoking static methods of a non-static field:)

---------
struct Foo
{
    static struct Bar
    {
        static int get() { return 0; }
    }

    Bar bar;
}

void main()
{
    static assert(Foo.bar.get() == 0);  // ok, equivalent to `typeof(Foo.bar).get()`
}
---------

$(P - When accessing static fields implicitly using an $(LINK2 class.html#AliasThis, $(D alias this)) expression:)

---------
struct Foo
{
    static struct Bar
    {
        static int get() { return 0; }
    }

    Bar bar;
    alias bar this;
}

void main()
{
    static assert(Foo.get() == 0);  // ok, equivalent to 'typeof(Foo.bar).get()'
}
---------
)
$(LI $(LNAME2 implicitarrayptr, Arrays no longer implicitly convert to a pointer:)

$(P The implicit conversion of an array to a pointer was a deprecated feature:)

---------
void foo(int* p) { }

void main()
{
    int[] arr = [1, 2];
    foo(arr);   // ok if -d switch is used during compilation
}
---------

$(P This feature has now been completely removed. The workaround is to either
    use the $(D .ptr) property, or explicitly pass the pointer to the first element:)

---------
void foo(int* p) { }

void main()
{
    int[] arr = [1, 2];
    foo(arr);      // compile error
    foo(arr.ptr);  // ok
    foo(&arr[0]);  // ok
}
---------
))
$(BUGSTITLE Language Enhancements,

$(LI $(LNAME2 uniqueinference, Expressions which return unique objects can be implicitly casted to immutable:)

$(P Expressions such as $(D new) for objects and arrays, and $(D dup) for arrays, can now be inferred to be unique.
    This allows the compiler to implicitly convert such an expression to immutable:)

---------
class C { }

void main()
{
    immutable int[] arr1 = new int[](3);   // ok
    immutable int[] arr2 = [1, 2, 3].dup;  // ok in 2.063
    immutable C[] arr3 = [new C, new C].dup;  // ok in 2.063
}
---------
)
$(LI $(LNAME2 staticarrayvoid, Static array of void can now be user-initialized.)

$(P A static array of void could not be initialized in user-code:)

---------
void main()
{
    void[2] varr1;  // error in 2.062
    void[2] varr2 = (void[2]).init;  // error in 2.062
    void[2] varr3 = void;  // ok in 2.062
}
---------

$(P In 2.063, an explicit initializer can be used:)

---------
void main()
{
    void[2] varr1;  // still an error in 2.063
    void[2] varr2 = (void[2]).init;  // ok in 2.063
    void[2] varr3 = void;  // ok in 2.063
}
---------

$(P The $(D .init) property effectively zero-initializes the array.)

$(H3 Rationale:)

$(P The restriction has been lifted to allow generic code to use $(D .init) without
having to specialize for static void arrays.))

$(LI $(LNAME2 multiinvariant, Aggregates can now contain multiple invariants:)

$(P If an aggregate type has multiple invariants, the invariants' bodies will be merged
    into a single invariant function and will be run in sequence. Note that the code in
    one invariant cannot reference code or data in another invariant:)

---------
struct S
{
    int x;

    void foo() { }

    invariant()
    {
        int local;
        assert(x != 0);
    }

    invariant()
    {
        // local = 1;  // invariant does not have access to the other invariant's body
        assert(x % 2 == 0);
    }
}

void main()
{
    S s = S(2);
    s.foo();  // invoking public function triggers both invariants in sequence
}
---------
)
$(LI $(LNAME2 attribinference, Methods of templated aggregates can now infer attributes:)

$(P If a function with some attributes instantiates a templated aggregate,
    it's member functions will infer those attributes:)

---------
struct S(T)
{
    T square(T x)
    {
        return x * x;
    }
}

void main() pure
{
    S!int s;  // S!int.square becomes pure and callable from main()
    assert(s.square(2) == 4);  // ok
}
---------
)
$(LI $(LNAME2 isexpident, $(B is expression) no longer requires an identifier:)

$(P In some cases the $(LINK2 expression.html#IsExpression, is expression) required an
    identifier even when you didn't have a use for it:)

---------
void main()
{
    alias AA = string[int];

    static if (is(AA _ == V[K], V, K))
    {
        pragma(msg, _);  // prints string[int]
        pragma(msg, K);  // prints int
        pragma(msg, V);  // prints string
    }
}
---------

$(P The identifier is no longer required, so the above can be rewritten to:)

---------
void main()
{
    alias AA = string[int];

    static if (is(AA == V[K], V, K))
    {
        pragma(msg, AA); // prints string[int]
        pragma(msg, K);  // prints int
        pragma(msg, V);  // prints string
    }
}
---------
)
$(LI $(LNAME2 implicitarraycast, Dynamic arrays of known size can be implicitly cast to static arrays in some contexts:)

$(P In some contexts the compiler knows the size of a dynamic array or of a slice of an array.
    In such a case the compiler will allow an implicit conversion to a static array of the same size:)

---------
void foo(int[4] x) { }

void main()
{
    int[] arr = [1, 2, 3, 4, 5, 6, 7, 8];
    foo(arr[0 .. 4]);  // ok
}
---------

$(P Another example, where a string is converted to a reference to a static array:)

---------
string str = "aaaabbbbccccdddd";

void foo(ref const(char)[16] buf)
{
    assert(buf.ptr is str.ptr);
}

void main()
{
    foo(str[0..16]);  // ok
}
---------

$(H3 Limitations:)

$(P - This feature does not yet work with complex expressions where it might be
    reasonable to assume the size of a slice:)

---------
void foo(int[4] x) { }

void main()
{
    int[] arr = [1, 2, 3, 4, 5, 6, 7, 8];
    foreach (i; 0 .. 4)
    {
        foo(arr[i .. i + 4]);  // not yet supported
    }
}
---------
)
$(LI $(LNAME2 tupleinitvoid, Tuples can now be void-initialized:)

$(P You can now void-initialize a tuple variable:)

---------
template Tuple(T...)
{
    alias T Tuple;
}

void main()
{
    Tuple!(int, int) tup1 = void;  // ok
}
---------

$(P Upon such initialization the values in the tuple are undetermined.))

$(LI $(LNAME2 templconstraint, Template constraints can now be put after the inheritance list:)

$(P Template constraints used to be allowed only before the inheritance list, leading to
    code where the inheritance list could be hard to spot:)

---------
class Foo(T1, T2)
    if (is(T1 == int) && is(T2 == string)) : Base
{
}
---------

$(P This restriction has been lifted, so you can now write:)

---------
class Foo(T1, T2) : Base
    if (is(T1 == int) && is(T2 == string))
{
}
---------
)
$(LI $(LNAME2 tupleequality, Tuples can now be compared for equality:)

$(P Example:)

---------
struct Tuple(T...) { T field; alias field this; }

void main()
{
    auto tup1 = Tuple!(int, int)(1, 2);
    auto tup2 = Tuple!(int, int)(1, 2);
    auto tup3 = Tuple!(int, int)(1, 3);

    assert(tup1 == tup2);  // works since 2.063
    assert(tup1 != tup3);  // works since 2.063
}
---------

$(P This also means you can now compare $(B ParameterStorageClassTuple) instances from std.traits:)

---------
import std.traits;

void func1(ref int x, ref int y) { }
void func2(ref float x, ref float y) { }

void main()
{
    alias Storages = ParameterStorageClassTuple;
    assert(Storages!func1 == Storages!func2);
}
---------

$(P In addition to that, builtin $(D .tupleof) expressions can be used to easily compare fields of an aggregate:)

---------
struct S
{
    char[] a, b;

    // Implements equality test against another instance of this type.
    bool opEquals(S rhs) { return this.tupleof == rhs.tupleof; }
}

void main()
{
    S s1 = S("a".dup, "b".dup);
    S s2 = S("a".dup, "b".dup);
    assert(s1 == s2);
}
---------

$(P This also allows you to implement a structural equality test against an instance of a different
    type:)

---------
struct S1
{
    char[] a, b;

    // Implements a structural equality test against any other type T
    bool opEquals(T)(T rhs) { return this.tupleof == rhs.tupleof; }
}

struct S2
{
    string x, y;
}

void main()
{
    auto s1 = S1("123".dup, "456".dup);
    auto s2 = S2("123", "456");
    assert(s1 == s2);
}
---------


$(P Since tuples can be sliced you can use this feature to compare a subset of tuples:)

---------
struct S
{
    int a, b, c, d, e;

    bool opEquals(S rhs)
    {
        // compares a, b, d, and e
        return this.tupleof[0..2] == rhs.tupleof[0..2] &&
               this.tupleof[3..5] == rhs.tupleof[3..5];
    }
}

void main()
{
    S s1 = S(1, 2, 0, 3, 4);
    S s2 = S(1, 2, 1, 3, 4);
    assert(s1 == s2);
}
---------
)
$(LI $(LNAME2 initfield, Fields with initializers can now be re-initialized in a const constructor:)

$(P You can now initialize a field in a const constructor even if
    such a field already has an initializer:)

---------
struct S
{
    bool field = true;

    this(int v) const
    {
        field = false;  // ok
    }
}
---------
)
$(LI $(LNAME2 isnestedtrait, Added the $(B isNested) trait for discovery of aggregates and functions with context pointers:)

$(P The new $(LINK2 traits.html#isNested, isNested) trait allows you to discover whether an aggregate or function
    contains a context pointer:)

---------
void main()
{
    int x;

    struct S1 { void f() { x++; } }
    static struct S2 { }

    void f1() { x++; }
    static void f2() { }

    static assert(__traits(isNested, S1));
    static assert(__traits(isNested, f1));
    static assert(!__traits(isNested, S2));
    static assert(!__traits(isNested, f2));
}
---------
)
$(LI $(LNAME2 nestedtemplate, Templates can now be nested inside of functions:))

---------
void test()
{
    template ArrayOf(T) { alias ArrayOf = T[]; }
    static assert(is(ArrayOf!int == int[]));
}
---------

$(P Allowing $(D template)'s inside of functions will enable better encapsulation and avoid the
    pollution of module-scoped symbol names.)

$(LI $(LNAME2 ufcslocalimport, UFCS now works with scoped local imports:)

$(P Functions that are made available through a local import are now picked up when using Uniform Function Call Syntax:)

---------
module foo;
string concat(string arg1, string arg2) { return arg1 ~ arg2; }
---------

---------
module test;
void main()
{
    import foo;
    assert("foo".concat("bar") == "foobar");  // UFCS now works
}
---------

$(P This feature also works for imports within aggregates. Note that local imports have a higher precedence than
    module-scoped imports.))

$(LI $(LNAME2 prettyfunc, Added $(D __FUNCTION__), $(D __PRETTY_FUNCTION__) and $(D __MODULE__):)

$(P A new set of $(LINK2 traits.html#specialkeywords, special keywords) were added. Together with $(D __FILE__) and $(D __LINE__) they form a complete feature set that is useful in debugging code:)

---------
module test;
import std.stdio;

void test(string file = __FILE__, size_t line = __LINE__, string mod = __MODULE__,
          string func = __FUNCTION__, string pretty = __PRETTY_FUNCTION__)
{
    writefln("file: '%s', line: '%s', module: '%s',\nfunction: '%s', pretty function: '%s'",
             file, line, mod, func, pretty);
}

int main(string[] args)
{
    test();
    return 0;
}
---------

$(P The above will output:)

$(CONSOLE
file: 'test.d', line: '13', module: 'test',
function: 'test.main', pretty function: 'int test.main(string[] args)'
))

$(LI $(LNAME2 deprecatedmacro, DDoc: Deprecated declarations are now wrapped in a $(B DEPRECATED) macro:)

---------
module test;

/// sum function
deprecated int sum(int x, int y) { return x + y; }
---------

$(P By default the macro expands to its argument. It can be overriden by the user, for example:)

$(P $(B macros.ddoc:))

---------
DEPRECATED=<del>$(DOLLAR)0</del>
---------

$(P The above ddoc file can then be used when the documentation is being generated:)

$(CONSOLE
$ dmd -D -o- test.d macros.ddoc
))

$(LI $(LNAME2 documentedunittest, Added documented unittest feature for verifiable code example generation:)

$(P Documented unittests which follow any symbol declarations are now used to generate example sections for the symbol
    when generating DDOC documentation. Example:)

---------
/// sum function
int sum(int x, int y) { return x + y; }

///
unittest
{
    assert(sum(2, 2) == 4);
}
---------

$(P The body of the unittest will be part of the documentation of the sum function. This allows the
    implementor of the function to keep their examples always up-to-date.)

$(P For more information, see the $(LINK2 unittest.html#documented-unittests, documentation page) of documented unittests.)

))


$(BUGSTITLE Compiler Enhancements,
$(LI $(LNAME2 mainswitch, Added -main switch which adds an empty main function:)

$(P The $(B -main) switch is primarily useful when unittesting libraries:)

---------
module test;

int sum(int a, int b) { return a + b; }
unittest
{
    assert(sum(2, 2) == 4);
}
---------

$(P The above library would need a $(B main()) function for the unittests to run,
    and $(B -main) can be used for this purpose:)

$(CONSOLE
$ dmd -unittest -main -run test.d
))

$(LI $(LNAME2 minimalcov, Added -cov=percentage switch for minimal coverage tests.)

$(P The $(B -cov) switch now has an optional percentage setting which makes the
    executable emit an error when the coverage doesn't meet the specified requirement:)

---------
module test;

void test1() { int x = 5; }
void test2() { int x = 5; }
void test3() { int x = 5; }

void main()
{
    test1();
    test2();
}
---------

$(P Example of coverage testing:)

$(CONSOLE
$ dmd -cov=90 test.d
$ test
Error: test.d is 80% covered, less than required 90%
))

$(LI $(LNAME2 symbolmangle, Added ability to override the mangling of a symbol with a compiler pragma:)

$(P The new $(CODE pragma(mangle, ...)) directive allows you to set a custom mangling for any symbol:)

---------
pragma(mangle, "module") extern(C) void module_();
---------

$(P The above allows linking to a C function named "module", which ordinarily we wouldn't be
    able to link to directly since "module" is a reserved D keyword.)

))

$(BUGSTITLE Phobos Changes,

$(LI $(LNAME2 scopedtypeof, std.typecons.scoped implementation changed, potentially breaking some user-code:)

$(P User-code which used the $(D std.traits.ReturnType) trait to retrieve the type of a $(D scoped) call will have to be
    changed to use the $(D typeof) operator instead:)

---------
class A
{
    this() {}
    this(int) {}
}

class B
{
    // ReturnType!(scoped!A) a;  // disallowed in 2.063
    typeof(scoped!A()) a;        // rewritten, compiles in 2.063

    this()
    {
        a = scoped!A(1);  // would not compile in 2.062, but works with syntax used for 2.063
    }
}
---------

$(P The reason for this change is that the $(D ReturnType) trait would retrieve the wrong type when a class
    had multiple constructors, and this would cause initializing the field to fail.)

$(P Another benefit of the new implementation is that $(D scoped) can now be aliased for usability purposes:)

---------
class A
{
    this(int) { }
}

void main()
{
    alias scoped!A scopeA;
    auto a = scopeA(1);
}
---------

))

$(BUGSTITLE Phobos Enhancements,

$(LI $(LNAME2 newstdprocess, $(STDMODREF process, std.process) has been redesigned from the ground up and introduces a new API and functionality:)

$(P The new $(STDMODREF process, std.process) module introduces functionality for invoking processes with custom pipe redirection,
the ability to wait for processes to finish, and the ability to kill processes. The full list of features
can be found in the $(STDMODREF process, std.process) documentation.))

$(LI $(LNAME2 getoptbool, $(STDMODREF getopt, std.getopt) can now set booleans to false:)

$(P Example code:)

---------
void main(string[] args)
{
    bool flag = true;
    getopt(args, &flag);
}
---------

$(P When invoked via $(CODE --flag=false), it will set $(B flag) to $(D false).))

$(LI $(LNAME2 ownertid, Added ownerTid property in $(STDMODREF concurrency, std.concurrency):)

$(P It is now easier to send a message from a child thread to its
owner thread. Simply use the $(B ownerTid) property to get the owner
thread's Tid identifier:)

---------
void fun()
{
    string res = receiveOnly!string();
    assert(res == "Main calling");

    ownerTid.send("Child responding");  // new
}

void main()
{
    auto child = spawn(&fun);
    child.send("Main calling");

    string res = receiveOnly!string();
    assert(res == "Child responding");
}
---------

$(P If the owner thread has exited, accessing ownerTid from any
    of its child threads will throw a $(B TidMissingException).)

))

$(BR)$(BIG $(LNAME2 list2063, List of all bug fixes and enhancements in D 2.063:))

$(BUGSTITLE DMD Compiler regressions,

$(P
$(LI $(BUGZILLA 9130): Wrong codegen for compile time constructed struct)
$(LI $(BUGZILLA 9258): opAssign with base class triggers "identity assignment operator overload" error)
$(LI $(BUGZILLA 9526): ICE when compiling project with unittests)
$(LI $(BUGZILLA 9536): IFTI fails when calling a static member from const member)
$(LI $(BUGZILLA 9538): Regression $(LPAREN)2.062$(RPAREN): Can't use typeid on .ptr of static array)
$(LI $(BUGZILLA 9539): Wrong implicit conversion of array to pointer)
$(LI $(BUGZILLA 9545): [REG 2.063a] ICE with member template instantiation)
$(LI $(BUGZILLA 9552): DMD crashed when taking member delegate from __traits$(LPAREN)getOverloads$(RPAREN))
$(LI $(BUGZILLA 9566): Regression $(LPAREN)2.062$(RPAREN): Cannot use struct .init when it contains a static array initialized from a single element.)
$(LI $(BUGZILLA 9568): [64bit] wrong code for scope$(LPAREN)exit$(RPAREN))
$(LI $(BUGZILLA 9633): compiles trait wrongly returns true even when object method call actually does not compile)
$(LI $(BUGZILLA 9650): __traits$(LPAREN)compiles$(RPAREN) + mixin)
$(LI $(BUGZILLA 9663): [REG2.063a] ICE caused by issue 7444 change.)
$(LI $(BUGZILLA 9672): mixin within cyclic import causes undefined properties)
$(LI $(BUGZILLA 9689): std.typecons.Proxy breaks with @disable this$(LPAREN)this$(RPAREN))
$(LI $(BUGZILLA 9694): A member struct that has mutable opEquals reports weird error message)
$(LI $(BUGZILLA 9739): Regression $(LPAREN)1.077 git-head$(RPAREN): DMD not considering ctor with default args as default ctor)
$(LI $(BUGZILLA 9759): compiler segfault in StructLiteral::implicitConvTo$(LPAREN)Type*$(RPAREN) on invalid code)
$(LI $(BUGZILLA 9764): Ddoc: Ddoc file name is incorrectly emphasized)
$(LI $(BUGZILLA 9775): Can no longer create a const Date in CTFE if the variable is explicitly typed)
$(LI $(BUGZILLA 9806): assertion failure in struct.c:668)
$(LI $(BUGZILLA 9834): incorrect detection of lambda locality.)
$(LI $(BUGZILLA 9846): regression of forward references)
$(LI $(BUGZILLA 9858): const alias this fails when opAssign is present)
$(LI $(BUGZILLA 9865): Crash on bogus import / circular reference)
$(LI $(BUGZILLA 9890): Alias This + Alias Fields)
$(LI $(BUGZILLA 9903): Broken ddoc in std.typecons and etc.c.sqlite3)
$(LI $(BUGZILLA 9919): Regression $(LPAREN)2.062$(RPAREN): Symbol lookup fails with public import and mixin)
$(LI $(BUGZILLA 9952): regression$(LPAREN)HEAD$(RPAREN): Attribute inference for virtual functions breaks subclasses)
$(LI $(BUGZILLA 9957): [2.061 -> 2.062] Taking pointer of enum float array gives some garbage)
$(LI $(BUGZILLA 9974): immutable class constructor is broken)
$(LI $(BUGZILLA 9984): inout qualifier is skipped for constructor arguments $(LPAREN)template constructor only$(RPAREN))
$(LI $(BUGZILLA 9987): Declaring struct ModuleInfo should be allowed)
$(LI $(BUGZILLA 10002): 2.062 -> 2.063 calling "remove" is impure)
$(LI $(BUGZILLA 10003): void* UFCS regression)
$(LI $(BUGZILLA 10016): Incorrect error gagging using RefCounted)
$(LI $(BUGZILLA 10040): struct-related ICE)
$(LI $(BUGZILLA 10041): ufcs writeln of associative array)
$(LI $(BUGZILLA 10043): ICE with __traits$(LPAREN)compiles$(RPAREN))
$(LI $(BUGZILLA 10044): Wrong di generation for IsExp with TemplateParameterList)
$(LI $(BUGZILLA 10047): opDispatch instantiation failure should be gagged for UFCS)
$(LI $(BUGZILLA 10049): Spurious "Label already defined" error inside a foreach over a range aggregate)
$(LI $(BUGZILLA 10050): Regression $(LPAREN)git-head$(RPAREN): RDMD no longer emits error messages from DMD)
$(LI $(BUGZILLA 10053): struct member with pure dtor forces declared dtor to be pure, too)
$(LI $(BUGZILLA 10055): Incorrect attribute merging in dtor/postblit building)
$(LI $(BUGZILLA 10056): Strange Error with templates and string.format)
$(LI $(BUGZILLA 10067): [REG] Recursive template instantiation)
$(LI $(BUGZILLA 10073): Default opEquals depends on class declaration order with DMD HEAD)
$(LI $(BUGZILLA 10076): expression.c:4310: virtual Expression* TypeExp::semantic$(LPAREN)Scope*$(RPAREN): Assertion `0` failed.)
$(LI $(BUGZILLA 10089): Strange function call error message with specified module)
$(LI $(BUGZILLA 10091): [HEAD] Cannot cast struct member string enum to static ubyte array of same size)
$(LI $(BUGZILLA 10096): Regression $(LPAREN)git-head$(RPAREN): __traits$(LPAREN)allMembers$(RPAREN) triggers out of bounds error)
$(LI $(BUGZILLA 10101): static if conditional cannot be at global scope using mixin template)
$(LI $(BUGZILLA 10106): [ICE] Ice in glue.c:1215 + 2 error messages without lines)
$(LI $(BUGZILLA 10134): Mutual referencing templates error)
$(LI $(BUGZILLA 10142): [REG2.063a] enum value semantic problem that declared in class member)
$(LI $(BUGZILLA 10144): Using enum inside final class occurs weird errors)
$(LI $(BUGZILLA 10148): regression 062=>063: unjustified 'safe function cannot call system function')
$(LI $(BUGZILLA 10151): final: before enum is now an error.)
$(LI $(BUGZILLA 10160): No line number "cannot modify struct ... with immutable members")
$(LI $(BUGZILLA 10166): XXX is not a template)
$(LI $(BUGZILLA 10178): Compiler segfault with zero-length tuple comparison)
)
)
$(BUGSTITLE DMD Compiler bugs,

$(P
$(LI $(BUGZILLA 1520): TypeInfo_Const.opEquals is incorrect)
$(LI $(BUGZILLA 1804): Severe GC leaks with repetitive array allocations)
$(LI $(BUGZILLA 2356): array literal as non static initializer generates horribly inefficient code.)
$(LI $(BUGZILLA 3789): [TDPL] Structs members that require non-bitwise comparison not correctly compared)
$(LI $(BUGZILLA 4094): ICE$(LPAREN)expression.c$(RPAREN): recursive struct templates with type inference)
$(LI $(BUGZILLA 4247): Cannot create default-constructed struct on heap when constructor is defined)
$(LI $(BUGZILLA 4414): ICE$(LPAREN)cgcs.c$(RPAREN) Taking item of static array returned by function)
$(LI $(BUGZILLA 4436): Double bug regarding Tuple.init)
$(LI $(BUGZILLA 4479): Module Foo is in multiple files Foo)
$(LI $(BUGZILLA 4617): Alias this'ed symbols cannot be passed to templates)
$(LI $(BUGZILLA 4814): rdmd: Doesn't rebuild when using -of and turning an -L linker option on or off)
$(LI $(BUGZILLA 5450): no match for implicit super$(LPAREN)$(RPAREN) call in constructor)
$(LI $(BUGZILLA 5625): std.format unittest disabled)
$(LI $(BUGZILLA 6070): CTFE UFCS forward reference error)
$(LI $(BUGZILLA 6089): __gshared with not static 2D array)
$(LI $(BUGZILLA 6153): Inserting to An Array!T inside an Array!$(LPAREN)Array!T$(RPAREN) causes a segfault.)
$(LI $(BUGZILLA 6312): template instance cannot use argument from enclosing template)
$(LI $(BUGZILLA 6431): [RDMD] Modifying a library doesn't trigger a rebuild)
$(LI $(BUGZILLA 6535): RDMD outputs broken library files)
$(LI $(BUGZILLA 6539): Incomprehensible error message with failed template instantiation)
$(LI $(BUGZILLA 6545): [CTFE] Hard-coded array operations not yet supported)
$(LI $(BUGZILLA 6578): Ignored const with struct with constructor)
$(LI $(BUGZILLA 6795): ICE$(LPAREN)cgcs.c$(RPAREN): Incrementing an enum array item)
$(LI $(BUGZILLA 6852): Cannot compare instances of ParameterStorageClassTuple)
$(LI $(BUGZILLA 7068): copying array of pointers calls memset instead of memcpy with -d)
$(LI $(BUGZILLA 7437): DMD enters infinite loop during overload resolution)
$(LI $(BUGZILLA 7569): cannot void initialize tuple declarations)
$(LI $(BUGZILLA 7572): f.fn!$(LPAREN)void$(RPAREN) is not an lvalue)
$(LI $(BUGZILLA 7719): enum forward reference error when enum is in braces)
$(LI $(BUGZILLA 7980): Stack overflow / recursive expansion with alias this)
$(LI $(BUGZILLA 8041): __gshared/static problem)
$(LI $(BUGZILLA 8081): pure nothrow unittest problem in generated 'header' file)
$(LI $(BUGZILLA 8130): Memory corruption because without *.def file DMD compiles DLL with assumption `_tls_index = 0`)
$(LI $(BUGZILLA 8213): Incorrect error message with pointer to ubyte[] and front)
$(LI $(BUGZILLA 8238): templates can create ghost fields)
$(LI $(BUGZILLA 8245): UFCS doesn't work for pointers)
$(LI $(BUGZILLA 8294): complex breaks calling in 64 bit DMD)
$(LI $(BUGZILLA 8347): Parser bug with const placed after ~this$(LPAREN)$(RPAREN) in decl)
$(LI $(BUGZILLA 8366): Overriding const member function in conjunction with mutable overload causes a strange error)
$(LI $(BUGZILLA 8589): Incorrect conversion of function returning `typeof$(LPAREN)null$(RPAREN)` to function returning an array)
$(LI $(BUGZILLA 8609): A forward reference error with static arrays)
$(LI $(BUGZILLA 8668): public selective import makes functions conflict when otherwise they don't)
$(LI $(BUGZILLA 8670): IFTI fails from aliases)
$(LI $(BUGZILLA 8697): Invalid error message: Forward reference of interface)
$(LI $(BUGZILLA 8698): Forward reference error with interfaces)
$(LI $(BUGZILLA 8827): Cannot move contents of R12)
$(LI $(BUGZILLA 8828): Long compilation time of a destroy$(LPAREN)$(RPAREN) on a large fixed-sized matrix)
$(LI $(BUGZILLA 8833): Odd error with expression tuples)
$(LI $(BUGZILLA 8902): Unexpected "duplicate union initialization for X" error)
$(LI $(BUGZILLA 8945): Can't call static struct initializer or constructor without qualifier for templated inner struct)
$(LI $(BUGZILLA 8953): Parser rejects qualifier after destructor i.e. `~this$(LPAREN)$(RPAREN) $(LESS)qualifier$(GREATER) { }`)
$(LI $(BUGZILLA 8989): cfloat argument passing broken)
$(LI $(BUGZILLA 8998): 'inout pure' returns immutable, which in reality is mutable)
$(LI $(BUGZILLA 9091): Using __traits$(LPAREN)getMember$(RPAREN) on template argument fails inside member function)
$(LI $(BUGZILLA 9144): synchronized CRITSECSIZE should be a target constant)
$(LI $(BUGZILLA 9199): Module level qualified functions should be rejected)
$(LI $(BUGZILLA 9209): ice$(LPAREN)symbol.c$(RPAREN) with const struct heap allocation)
$(LI $(BUGZILLA 9231): overriding inout funcion with attribute inference reports weird error)
$(LI $(BUGZILLA 9232): Parsing error on some templated methods calls)
$(LI $(BUGZILLA 9241): 2.061: Property call error message disappeared)
$(LI $(BUGZILLA 9280): Runtime range violation with named capture groups in regex)
$(LI $(BUGZILLA 9311): shared library file extension incorrectly modified)
$(LI $(BUGZILLA 9345): CTFE fails when using std.string.format with imported string enum)
$(LI $(BUGZILLA 9346): nested struct calls disabled postblit)
$(LI $(BUGZILLA 9386): struct destructor called erroneously)
$(LI $(BUGZILLA 9393): Partial template specialization and template lambda does not work)
$(LI $(BUGZILLA 9401): destructor and nothrow syntax)
$(LI $(BUGZILLA 9413): Incorrect modification inside contracts is not detected correctly)
$(LI $(BUGZILLA 9414): Incorrect modification inside contracts is not detected on virtual function)
$(LI $(BUGZILLA 9415): delegate inference should make function literal impure)
$(LI $(BUGZILLA 9417): "no size yet for forward reference" error with nested structure)
$(LI $(BUGZILLA 9428): Wrong array concatenation)
$(LI $(BUGZILLA 9441): struct constructor missed on auto/type-inferred variable definition)
$(LI $(BUGZILLA 9445): interpret.c:151: Assertion `v->ctfeAdrOnStack >= 0 && v->ctfeAdrOnStack < stackPointer$(LPAREN)$(RPAREN)` failed.)
$(LI $(BUGZILLA 9451): Listing abstract functions in diagnostic should show full signature)
$(LI $(BUGZILLA 9473): Unittest docs should each be in their own section)
$(LI $(BUGZILLA 9474): Ddoc'd unittests should work correctly with interspersed version$(LPAREN)none$(RPAREN))
$(LI $(BUGZILLA 9475): Should retain source formatting in ddoc's unittests)
$(LI $(BUGZILLA 9480): The template name in the JSON output contains template and function arguments)
$(LI $(BUGZILLA 9494): compiler stack overflow on invalid associative array)
$(LI $(BUGZILLA 9495): Win64 vararg issue when first argument is > 8 byte)
$(LI $(BUGZILLA 9508): RDMD doesn't generate new dependency list when a file is changed.)
$(LI $(BUGZILLA 9540): Compiler crash on delegate context frame assignment)
$(LI $(BUGZILLA 9561): Many error messages from std.format)
$(LI $(BUGZILLA 9590): UFCS does not work with void lazy expressions)
$(LI $(BUGZILLA 9613): Parser bug when using .init with type constructor)
$(LI $(BUGZILLA 9617): ulong.max is wrongly accepted by smaller signed parameter)
$(LI $(BUGZILLA 9619): Failed struct field typeof in inner function)
$(LI $(BUGZILLA 9622): Range violation in rdmd)
$(LI $(BUGZILLA 9649): DMD doesn't parse valid PostfixExpression . NewExpression syntax.)
$(LI $(BUGZILLA 9652): __traits$(LPAREN)getAttributes$(RPAREN) doesn't work with manifest constants)
$(LI $(BUGZILLA 9654): Template function cannot take string by ref T[len])
$(LI $(BUGZILLA 9656): Built-in dup result should behave as like unique array, if it is possible.)
$(LI $(BUGZILLA 9658): Setting pre-initialized field should be allowed in qualified constructor.)
$(LI $(BUGZILLA 9677): Crash on setting length property of array VC 2012 64 bit)
$(LI $(BUGZILLA 9679): Refused const/immutable assignment in conditional)
$(LI $(BUGZILLA 9692): __traits$(LPAREN)allMembers$(RPAREN) fails on module without a package)
$(LI $(BUGZILLA 9700): std.typecons.Proxy with invaliant and in-place operation causes Access Violation)
$(LI $(BUGZILLA 9712): IFTI does not support deducing static array types from array literal arguments)
$(LI $(BUGZILLA 9713): Ddoc: Empty description suppress automatic example generation)
$(LI $(BUGZILLA 9714): Ddoc: Combination of -D and -unittest reveals hidden unittest function)
$(LI $(BUGZILLA 9720): OSX wrong code with -O Illegal instruction)
$(LI $(BUGZILLA 9722): optimizer kills GOT to EBX load)
$(LI $(BUGZILLA 9729): interface thunk doesn't set EBX to GOT)
$(LI $(BUGZILLA 9735): Casting delegates to void* should be illegal)
$(LI $(BUGZILLA 9736): VS2010 project file does full rebuild every time)
$(LI $(BUGZILLA 9743): IFTI and polymorphic string literal should support implicit conversion to static array type)
$(LI $(BUGZILLA 9744): Poor error message taking address of thread-local variable at compile time)
$(LI $(BUGZILLA 9747): IFTI argument deduction fails for committed string literals which are implicitly converted to a static array)
$(LI $(BUGZILLA 9755): JSON output is missing the protection attribute for templates)
$(LI $(BUGZILLA 9757): Ddoc: documented unittest after ditto should work)
$(LI $(BUGZILLA 9758): Ddoc: empty ddoc comment and unittest block generates no Examples section)
$(LI $(BUGZILLA 9768): No line number for wrong foreach type)
$(LI $(BUGZILLA 9773): ref parameter with default value should not compile)
$(LI $(BUGZILLA 9774): Error message with __error using == on tuple members)
$(LI $(BUGZILLA 9777): Calling final interface method leads to wrong code)
$(LI $(BUGZILLA 9781): -inline will cause backend ICE)
$(LI $(BUGZILLA 9788): -profile doesn't work if exceptions are thrown in the running program)
$(LI $(BUGZILLA 9790): Internal error when compiling a invalid variable in template $(LPAREN)in expression.c and backend\evalu8.c$(RPAREN))
$(LI $(BUGZILLA 9791): [ICE] $(LPAREN)struct.c line 668$(RPAREN) map with a missing tuple import)
$(LI $(BUGZILLA 9818): Constant folding for static array does not work with initializing by element)
$(LI $(BUGZILLA 9829): rdmd passes '--' to dmd)
$(LI $(BUGZILLA 9837): IFTI should consider enum base type)
$(LI $(BUGZILLA 9844): DMD $(LPAREN)-m64$(RPAREN) int long initialisation bug)
$(LI $(BUGZILLA 9845): enum value should be able to contain forward references in global scope)
$(LI $(BUGZILLA 9863): Incorrect generation of SAHF instruction on 64 bits)
$(LI $(BUGZILLA 9873): Built-in tuple should support equality comparison)
$(LI $(BUGZILLA 9874): Function call syntax disuniformity in template constraints)
$(LI $(BUGZILLA 9880): Redundant template instance displaying in error message)
$(LI $(BUGZILLA 9883): Error on using property as new dynamic array size)
$(LI $(BUGZILLA 9885): IFTI should consider known tuple types.)
$(LI $(BUGZILLA 9892): [ICE] forward reference in enum declaration members causes compiler segfault)
$(LI $(BUGZILLA 9899): struct with pure/nothrow destructor cannot be used as a struct member in pure/nothrow functions)
$(LI $(BUGZILLA 9901): string return from inner template function error)
$(LI $(BUGZILLA 9907): Struct literal with destructor should match to non-ref overload)
$(LI $(BUGZILLA 9910): Scalar op vector is broken.)
$(LI $(BUGZILLA 9928): ice with void* and function literal)
$(LI $(BUGZILLA 9936): Wrong opBinary/opBinaryRight rewrite.)
$(LI $(BUGZILLA 9939): allMembers trait doesn't returns members of nested anonymous enum)
$(LI $(BUGZILLA 9940): ICE applying getProtection to a functions obtained using getOverloads.)
$(LI $(BUGZILLA 9946): A UFCS disallowed in dynamic array allocation)
$(LI $(BUGZILLA 9961): Using UFCS properties suppress actual errors)
$(LI $(BUGZILLA 9965): Wrong Assembly For DIL, SIL Registers)
$(LI $(BUGZILLA 9971): eponymous function is not an lvalue)
$(LI $(BUGZILLA 9985): Postblit isn't called on local struct return)
$(LI $(BUGZILLA 9990): templates with function alias cause forward reference error)
$(LI $(BUGZILLA 9993): const ctor should be preferred than mutable for const obj creation)
$(LI $(BUGZILLA 9994): Built-in generated opAssign should call dtor on assignment)
$(LI $(BUGZILLA 10004): tuple comparison with side-effect should work)
$(LI $(BUGZILLA 10005): struct variable declaration and const-correctness)
$(LI $(BUGZILLA 10011): Wrong JSON "init" property output for class reference initializers)
$(LI $(BUGZILLA 10029): Update list of reserved version identifiers.)
$(LI $(BUGZILLA 10058): Inconsistent mangling between C++ and extern$(LPAREN)C++$(RPAREN).)
$(LI $(BUGZILLA 10059): export doesn't work for variable declarations)
$(LI $(BUGZILLA 10063): inout+pure results in ability to produce immutable reference to mutable data)
$(LI $(BUGZILLA 10066): Template opEquals sometimes obstructs struct compilation)
$(LI $(BUGZILLA 10102): @disable incompletely implemented)
$(LI $(BUGZILLA 10103): template mixin with property overloads)
$(LI $(BUGZILLA 10105): ICE when converting string literal to static char array in enum initializer)
$(LI $(BUGZILLA 10115): More @disabled holes)
$(LI $(BUGZILLA 10171): Unexpected error "cannot infer type from overloaded function symbol")
$(LI $(BUGZILLA 10180): offsetof doesn't work through function call alias this)
)
)
$(BUGSTITLE DMD Compiler enhancements,

$(P
$(LI $(BUGZILLA 3449): const and invariant struct members do not behave according to spec)
$(LI $(BUGZILLA 3502): Fix for dropped Mac OS X 10.5)
$(LI $(BUGZILLA 3673): inheritance + if clause = no go)
$(LI $(BUGZILLA 4528): Better error message for private abstract method)
$(LI $(BUGZILLA 5140): Add __FUNCTION__, __PRETTY_FUNCTION__, and __MODULE__)
$(LI $(BUGZILLA 6185): Include non-global functions when resolving UFCS)
$(LI $(BUGZILLA 6453): Allow multiple invariant per struct/class)
$(LI $(BUGZILLA 6809): IFTI should imply const where inout is present on args, but not on return type)
$(LI $(BUGZILLA 7444): Require [] for array copies too)
$(LI $(BUGZILLA 7511): attribute inference should work for template functions)
$(LI $(BUGZILLA 8220): invalid function call not detected during semantic analysis)
$(LI $(BUGZILLA 8669): TemplateThisParameter should change member function's qualifier)
$(LI $(BUGZILLA 8819): void static array should have init built-in propert)
$(LI $(BUGZILLA 8959): IsExpression should support syntax which has no Identifier in all cases)
$(LI $(BUGZILLA 9033): Remove  __thread from the language)
$(LI $(BUGZILLA 9136): Add isNested trait)
$(LI $(BUGZILLA 9155): Ddoc: code section should strip leading spaces)
$(LI $(BUGZILLA 9170): CTFE: Allow reinterpret casts float $(LESS)-$(GREATER) int)
$(LI $(BUGZILLA 9185): Add note about where -op is useful)
$(LI $(BUGZILLA 9574): Diagnostic for old use of 'alias this = that' should be informative)
$(LI $(BUGZILLA 9627): Not good enough error messages in some cases when using UFCS)
$(LI $(BUGZILLA 9635): Improved error message for failed access of array field properties from static method)
$(LI $(BUGZILLA 9676): Ddoc: Wrap deprecated declarations in a $$(LPAREN)DEPRECATED$(RPAREN) macro)
$(LI $(BUGZILLA 9680): Include entry point location in "dmd -v -o-" output)
$(LI $(BUGZILLA 9723): Implement -main switch to inject a default main$(LPAREN)$(RPAREN) function)
$(LI $(BUGZILLA 9726): Add minimum % coverage required for -cov testing)
$(LI $(BUGZILLA 9727): Documented unittest comment should appear before Example section)
$(LI $(BUGZILLA 9745): Allow non-thread local static variables to have their address taken in CTFE)
$(LI $(BUGZILLA 9778): RDMD: Support passing resource files to DMD)
$(LI $(BUGZILLA 9789): Ddoc for aliases should use new "alias x=y" syntax)
$(LI $(BUGZILLA 9866): movsxd not supported)
$(LI $(BUGZILLA 9920): [Optimizer] Use mul/imul for integer division by constant)
$(LI $(BUGZILLA 9941): [CTFE] Allow to store "newed" classes and structs in the data segment)
$(LI $(BUGZILLA 9943): Allow to return typeid from CTFE)
$(LI $(BUGZILLA 9963): Absurdly Inefficient Codegen For Adding Boolean Predicates)
$(LI $(BUGZILLA 9977): Function local templates should be allowed)
$(LI $(BUGZILLA 10030): Support '-l:' switch when passing default library to ld)
$(LI $(BUGZILLA 10077): add pragma$(LPAREN)mangle, "..."$(RPAREN) to override symbol mangle.)
$(LI $(BUGZILLA 10109): add -transition compiler switch to aid in dealing with breaking changes)
$(LI $(BUGZILLA 10150): Prefix method 'this' qualifiers should be just ignored anytime)
$(LI $(BUGZILLA 10179): Tuple assignment should not cause "has no effect" error even if the length is zero)
)
)
$(BUGSTITLE Phobos regressions,

$(P
$(LI $(BUGZILLA 9122): std.concurrency send$(LPAREN)$(RPAREN) fails with multiple arrays)
$(LI $(BUGZILLA 9742): std.math.floor returns 0 for any value x > -1 and x $(LESS) 0)
$(LI $(BUGZILLA 10122): `Appender` doesn't work with disabled default construction)
)
)
$(BUGSTITLE Phobos bugs,

$(P
$(LI $(BUGZILLA 3795): Problem with phobos std.variant)
$(LI $(BUGZILLA 4729): std.algorithm: strange iota behaviour)
$(LI $(BUGZILLA 4798): std.algorithm.map unusable for ranges with const elements)
$(LI $(BUGZILLA 4955): struct dirent.d_type is not a mask)
$(LI $(BUGZILLA 5032): std.file.rename acts differently on Windows and Linux when the target file already exists.)
$(LI $(BUGZILLA 5201): std.string.indexOf and std.algorithm.indexOf return different things for narrow strings)
$(LI $(BUGZILLA 5310): Variant == const$(LPAREN)Variant$(RPAREN) doesn't compile)
$(LI $(BUGZILLA 5359): std.traits.isDelegate should work for types and expressions)
$(LI $(BUGZILLA 5360): calling rdmd from different folder)
$(LI $(BUGZILLA 5514): Erroneous documentation and lacking randomization for topN)
$(LI $(BUGZILLA 5658): Undocumented fields in std.typecons.Tuple)
$(LI $(BUGZILLA 5924): schwartzSort of Tuple!$(LPAREN)char$(RPAREN)[])
$(LI $(BUGZILLA 8321): std.range.put doesn't work with RefCounted output range)
$(LI $(BUGZILLA 8613): std.typecons.Proxy cannot work with operator 'in')
$(LI $(BUGZILLA 8655): bitfields and Typedef don't mix)
$(LI $(BUGZILLA 9164): Can't easily assign one Nullable to another)
$(LI $(BUGZILLA 9431): Tuple creation problem with array of array)
$(LI $(BUGZILLA 9456): decodeFront is inconsistent in whether it pops elements off of the range or not)
$(LI $(BUGZILLA 9512): std.regex: Incorrect parsing of hex sequences composed from capital letters.)
$(LI $(BUGZILLA 9553): SOCKET should be 64 bit wide on Win64)
$(LI $(BUGZILLA 9583): std.getopt.getopt does not consume options terminator "--" from args list, as docs claim)
$(LI $(BUGZILLA 9612): std.range.Cycle.opSlice tests on the bounds are missing)
$(LI $(BUGZILLA 9624): fullyQualifiedName fails for functions)
$(LI $(BUGZILLA 9648): Missing std.random import for std.algorithm.topN)
$(LI $(BUGZILLA 9753): std.string.translate precondition asserts)
$(LI $(BUGZILLA 9794): std.json cannot handle delete character)
$(LI $(BUGZILLA 9804): `std.math.FloatingPointControl` corrupts floating point state)
$(LI $(BUGZILLA 9812): std.conv.parse string fails on certain escape characters.)
$(LI $(BUGZILLA 9836): std.array.popFront does not work with alias this.)
$(LI $(BUGZILLA 9950): std.json should return empty string/array instead of null on empty input)
$(LI $(BUGZILLA 9956): hasElaborateAssign trait does not work with static arrays)
$(LI $(BUGZILLA 9979): Regex bug with \b and look-behind)
$(LI $(BUGZILLA 10116): stdio.File.byLine repeats last line forever, readln$(LPAREN)ref C[],R$(RPAREN) returns bad data)
$(LI $(BUGZILLA 10167): Wrong Document Comment on std.format.d$(LPAREN)181$(RPAREN))
$(LI $(BUGZILLA 10182): std.bitmanip unit test has pointless/unused foreach loop)
)
)
$(BUGSTITLE Phobos enhancements,

$(P
$(LI $(BUGZILLA 4787): std.algorithm.bisectRight$(LPAREN)$(RPAREN))
$(LI $(BUGZILLA 4921): Synopsis code in std.variant documentation throws an assertion error)
$(LI $(BUGZILLA 5013): std.typecons.Tuple should have constructor for static arrays)
$(LI $(BUGZILLA 5106): makeIndex should return SortedRange)
$(LI $(BUGZILLA 5226): indexOf$(LPAREN)$(RPAREN) which takes a pred but no needle)
$(LI $(BUGZILLA 5401): std.socket updates and boost license)
$(LI $(BUGZILLA 5507): countUntil should take Ranges... instead of R2)
$(LI $(BUGZILLA 6224): Add an ownerTid property in std.concurrency)
$(LI $(BUGZILLA 6486): std.math.abs$(LPAREN)BigInt$(RPAREN))
$(LI $(BUGZILLA 7405): std.algorithm.schwartzSort.release)
$(LI $(BUGZILLA 9260): getopt should allow setting booleans to false)
$(LI $(BUGZILLA 9265): Nullable fixed-sized array wrapper)
$(LI $(BUGZILLA 9625): assertNotThrown should print exception msg if no msg is provided)
$(LI $(BUGZILLA 9802): Add `std.traits.{isNested,hasNested}`.)
$(LI $(BUGZILLA 9814): Add std.traits.isNestedFunction)
$(LI $(BUGZILLA 9839): std.traits.Select should be able to select symbols)
$(LI $(BUGZILLA 9888): Allow passing a generator to std.random.uniform for enums)
)
)
$(BUGSTITLE Druntime bugs,

$(P
$(LI $(BUGZILLA 4307): spawn$(LPAREN)$(RPAREN)'ed thread doesn't terminate)
$(LI $(BUGZILLA 6024): Document that Windows 2000 SP4 is no longer supported)
$(LI $(BUGZILLA 10057): [2.063 beta] Module info overwritten in shared phobos.)
$(LI $(BUGZILLA 10081): Incorrect char array comparison)
)
)
$(BUGSTITLE Optlink bugs,

$(P
$(LI $(BUGZILLA 6144): Unexpected OPTLINK Termination at EIP=00428DA3)
)
)
$(BUGSTITLE Installer bugs,

$(P
$(LI $(BUGZILLA 9343): Problem installing dmd-2.061-0.fedora.x86_64.rpm on Fedora 18)
)
)
$(BUGSTITLE Website bugs,

$(P
$(LI $(BUGZILLA 4847): std.algorithm.topN documentation)
$(LI $(BUGZILLA 9544): D logo image is broken on non-root-level pages)
$(LI $(BUGZILLA 9609): Ddoc tags for std.string.icmp seem wrong)
$(LI $(BUGZILLA 10036): missing core.atomic docs on dlang.org)
)
))

$(VERSION 062, Feb 18, 2013, =================================================,
$(BUGSTITLE Language Changes,

$(LI $(D typeof()) change:)

$(P As a result of fixing $(BUGZILLA 6408), the usage of $(D typeof()) and indexing may require changes to user code:)

---------
template ElementTypeOf(T)
{
    alias typeof(T[0]) ElementTypeOf;
}

void main()
{
    // worked in 2.061 due to a bug
    static assert(is(ElementTypeOf!(int[]) == int));
}
---------

$(P The expression in $(D typeof(T[0])) used to be wrongly interpreted as the element type of $(B T), however in v2.062 it is interpreted as a static array of element $(B T) with length 0. To work around this the user can either use a trait from the standard library, or use the $(D .init) property of a type for arbitrary expressions:)

---------
import std.range;

template ElementTypeOf(T)
{
    // use T.init
    alias typeof(T.init[0]) ElementTypeOf;
}

void main()
{
    // use std.range.ElementType
    static assert(is(ElementType!(int[]) == int));

    // use custom template after fixing its code
    static assert(is(ElementTypeOf!(int[]) == int));
}
---------

$(LI $(D alias) syntax change:)

$(P The newly introduced "$(D alias foo = int)" syntax is not usable with
$(DDSUBLINK class, AliasThis, subtyping). This is to prevent confusion from a possible future syntax which would enable aliasing of super constructors. For now, the existing $(D alias) syntax can be used:)

---------
struct S
{
    int x;
    // alias this = x;  // error
    alias x this;
}
---------

$(P In the upcoming release (v2.063) a new syntax will be introduced:)

---------
struct S
{
    int x;
    alias this : x;  // new feature in upcoming 2.063
}
---------

)

$(BR)$(BIG List of all bug fixes and enhancements:)

$(BUGSTITLE DMD Compiler regressions,

$(P
$(LI $(BUGZILLA 9174): regression$(LPAREN)2.057$(RPAREN) ice$(LPAREN)cast.c$(RPAREN) with ternary operator and alias this)
$(LI $(BUGZILLA 9244): union containing pointers not allowed)
$(LI $(BUGZILLA 9258): opAssign with base class triggers "identity assignment operator overload" error)
$(LI $(BUGZILLA 9259): Passing an array of pointers to a typesafe vararg is broken)
$(LI $(BUGZILLA 9263): statement is not reachable when statement is reachable)
$(LI $(BUGZILLA 9266): Cannot define two Tuple objects.)
$(LI $(BUGZILLA 9268): [ice-on-invalid] void assignment in fail44.d no longer caught in frontend)
$(LI $(BUGZILLA 9273): DMD segfaults with templated ctors in implicit super call)
$(LI $(BUGZILLA 9276): regression$(LPAREN)2.061$(RPAREN): Forward reference error)
$(LI $(BUGZILLA 9278): ICE todt.c:692 when float containing struct is defined after use)
$(LI $(BUGZILLA 9309): Regression $(LPAREN)2.061$(RPAREN): -O -release generates wrong code)
$(LI $(BUGZILLA 9332): [REG][2.060 -> 02.061] struct constructor taking itself creates 'Warning: statement is not reachable')
$(LI $(BUGZILLA 9377): Link-failure regression cause by fixing issue 8504)
$(LI $(BUGZILLA 9385): [Regression 2.057] null literal should be implicitly convertible to bool)
$(LI $(BUGZILLA 9387): Compiler switch -O changes behavior of correct code)
$(LI $(BUGZILLA 9399): ICE with nested function, template alias parameter, -inline, depending on order of source files)
$(LI $(BUGZILLA 9404): Nullable is unusable with 2.061)
$(LI $(BUGZILLA 9406): $(LPAREN)Regression: 2.061$(RPAREN) Stack overflow from a forward reference error)
$(LI $(BUGZILLA 9409): [2.062-alpha] Regression with $ inside of expression tuples)
$(LI $(BUGZILLA 9410): [Regression 2.061] Wrong selection for function overload)
$(LI $(BUGZILLA 9416): [REG][2.060 -> 02.061] DMD eagerly instantiates template parameter-less opAssign)
$(LI $(BUGZILLA 9420): [2.062alpha] Weird "$(LPAREN)null$(RPAREN)" output in error message)
$(LI $(BUGZILLA 9435): regression$(LPAREN)head$(RPAREN): forward reference error)
$(LI $(BUGZILLA 9436): enum cannot be forward referenced with cyclic imports and mixin)
$(LI $(BUGZILLA 9496): [REG 2.061 -> 2.062 alpha] "this[1 .. $]" passes wrong "this" to "opDollar")
$(LI $(BUGZILLA 9514): "template instance … is not an alias")
$(LI $(BUGZILLA 9525): [CTFE] Cannot convert &S to const$(LPAREN)S*$(RPAREN) at compile time)
)

)

$(BUGSTITLE DMD Compiler bugs,

$(P
$(LI $(BUGZILLA 1369): Unable to find 'this' in __traits$(LPAREN)getMember$(RPAREN))
$(LI $(BUGZILLA 1730): Bogus error message calling a non-const struct method on a const struct reference)
$(LI $(BUGZILLA 1841): Closure detection doesn't work when variable is used in a nested function)
$(LI $(BUGZILLA 2452): Unimplemented method errors should show function overload)
$(LI $(BUGZILLA 3321): debug flags)
$(LI $(BUGZILLA 3466): Wrong JSON output for templated classes, structs, and interfaces)
$(LI $(BUGZILLA 4178): destructor missing in JSON output)
$(LI $(BUGZILLA 4269): Regression$(LPAREN)2.031$(RPAREN): invalid type accepted if evaluated while errors are gagged)
$(LI $(BUGZILLA 4477): JSON output for function definitions includes insufficient type information)
$(LI $(BUGZILLA 4478): JSON output omits import statements)
$(LI $(BUGZILLA 4540): Better error message for wrong switch type)
$(LI $(BUGZILLA 5168): String enums don't work with -g compiler switch)
$(LI $(BUGZILLA 5461): Invalid declaration for auto functions in .di files generated by DMD -H)
$(LI $(BUGZILLA 5933): Cannot retrieve the return type of an auto-return member function)
$(LI $(BUGZILLA 5978): ICE$(LPAREN)mtype.c$(RPAREN) when calling __traits$(LPAREN)parent$(RPAREN) on the child of an anonymous function.)
$(LI $(BUGZILLA 6057): Problem with defining enum in function)
$(LI $(BUGZILLA 6319): debug's relaxed purity does not apply to nested scopes)
$(LI $(BUGZILLA 6332): Auto-return function cannot be inferred as @safe)
$(LI $(BUGZILLA 6408): string[].init gives a wrong type)
$(LI $(BUGZILLA 6538): ICE$(LPAREN)mangle.c$(RPAREN) Invalid template constraints)
$(LI $(BUGZILLA 6552): Wrong fallthrough warning for CaseRange)
$(LI $(BUGZILLA 6652): foreach parameter with number range is always ref)
$(LI $(BUGZILLA 6708): immutable ref implicit cast to const ref)
$(LI $(BUGZILLA 6743): ICE$(LPAREN)mars.c$(RPAREN) attempting to compile an exe file)
$(LI $(BUGZILLA 6833): Floating point literals lose fractional part in headers)
$(LI $(BUGZILLA 6873): Multiple storage class is not allowed on template argument)
$(LI $(BUGZILLA 6902): Different "pure nothrow int$(LPAREN)$(RPAREN)" types)
$(LI $(BUGZILLA 6905): ref acts as auto ref when return type is missing)
$(LI $(BUGZILLA 6962): Wrong Code With Scope Exit and Array Parameter, only with -O)
$(LI $(BUGZILLA 6963): pure/nothrow inference doesn't work for function pointers)
$(LI $(BUGZILLA 7152): Can't assign null to default argument)
$(LI $(BUGZILLA 7159): Forward reference when casting auto return method)
$(LI $(BUGZILLA 7252): ICE$(LPAREN)template.c$(RPAREN): 'global.errors' on line 4893 in file 'template.c')
$(LI $(BUGZILLA 7408): traits compiles fails for built-in properties of template instances)
$(LI $(BUGZILLA 7420): Duplicate "cannot be read at compile time" error messages)
$(LI $(BUGZILLA 7585): functions in templates inferred as delegate)
$(LI $(BUGZILLA 7740): unicodeProperties cannot be read at compile time for ctRegex)
$(LI $(BUGZILLA 7950): Type tuples are incorrectly flattened in base type list of interface)
$(LI $(BUGZILLA 8053): Recursive alias this causes infinite loop)
$(LI $(BUGZILLA 8152): Linking C library causes Seg-fault)
$(LI $(BUGZILLA 8153): Warning about toHash signature is incorrect on x86_64)
$(LI $(BUGZILLA 8504): Template attribute inferrence doesn't work)
$(LI $(BUGZILLA 8583): [64 bit] AA ushort[dchar] byValue range is corrupted on x86_64)
$(LI $(BUGZILLA 8631): illegal overrides accepted)
$(LI $(BUGZILLA 8717): `private` and `protected` restrict member usage in same module)
$(LI $(BUGZILLA 8741): wrong code for struct member initialized using struct constructor)
$(LI $(BUGZILLA 8742): Anonymous nested class derived from another nested class makes DMD crash)
$(LI $(BUGZILLA 8763): struct initialization with empty variadic arguments tries to call constructor)
$(LI $(BUGZILLA 8783): ref foreach update of const fixed size arrays in constructor)
$(LI $(BUGZILLA 8787): Virtual not abstract methods in interfaces error message)
$(LI $(BUGZILLA 8832): Segfault when accessing range returned by function that has delegate referencing local variables)
$(LI $(BUGZILLA 8847): voldemort + inout confuses "is")
$(LI $(BUGZILLA 8892): Wrong diagnostic for static array assignment)
$(LI $(BUGZILLA 8898): false positive dangling else warning)
$(LI $(BUGZILLA 8913): Wrong code in IfStatement condition Expression)
$(LI $(BUGZILLA 8922): __traits$(LPAREN)parent, $(LESS)imported package$(GREATER)$(RPAREN) shows current module as a parent)
$(LI $(BUGZILLA 8969): is$(LPAREN)T == __parameters$(RPAREN) is undocumented)
$(LI $(BUGZILLA 8982): ICE$(LPAREN)ctfeexpr.c$(RPAREN) __parameters of an erroneous default parameter)
$(LI $(BUGZILLA 9018): __traits$(LPAREN)compiles, ...$(RPAREN) is true on second check for same incompilable code)
$(LI $(BUGZILLA 9083): mixin expression on template argument doesn't work)
$(LI $(BUGZILLA 9113): ICE$(LPAREN)interpret.c$(RPAREN): CTFE assignment to member of struct in union)
$(LI $(BUGZILLA 9178): UDA: getAttributes does not play well with tupleof)
$(LI $(BUGZILLA 9191): Unhelpful error message on failing override)
$(LI $(BUGZILLA 9195): Should not be able to index a pointer in safed)
$(LI $(BUGZILLA 9198): Vararg functions don't respect IFTI rules)
$(LI $(BUGZILLA 9200): Wrong SIMD code generated)
$(LI $(BUGZILLA 9208): [ICE]$(LPAREN)func.c line 1205$(RPAREN) with auto return in recursive function)
$(LI $(BUGZILLA 9236): CTFE ice on switch + with$(LPAREN)EnumType$(RPAREN))
$(LI $(BUGZILLA 9250): Wrong line number for error involving length of a static array)
$(LI $(BUGZILLA 9254): ICE on invalid foreach aggregate)
$(LI $(BUGZILLA 9264): [64bit] Wrong code with conversion from int parameter to float)
$(LI $(BUGZILLA 9284): DMD segfaults with templated ctors in constructor delegation)
$(LI $(BUGZILLA 9291): [ICE][REG] throwing undefined identifier with nothrow crashes dmd)
$(LI $(BUGZILLA 9293): enum struct with StructInitializer reports weird error)
$(LI $(BUGZILLA 9304): Unary minus operator doesn't work correctly with SIMD types.)
$(LI $(BUGZILLA 9305): Ugly Ddoc for default template lambda expressions)
$(LI $(BUGZILLA 9312): with statement error message is wrong)
$(LI $(BUGZILLA 9315): ICE $(LPAREN)expression.c:4249, StructLiteralExp::getField$(RPAREN) Tupleof of nested struct literal)
$(LI $(BUGZILLA 9320): optimizer should do copy propagation on structs, too)
$(LI $(BUGZILLA 9322): Internal error: ../ztc/cod1.c 3510 with SIMD on OSX 32)
$(LI $(BUGZILLA 9330): Cannot run dmd test suite with MSYS)
$(LI $(BUGZILLA 9338): Compiler segfaults if try to CTFE member function without valid 'this')
$(LI $(BUGZILLA 9348): "tmpl!arg" syntax followed by "!is" or "!in")
$(LI $(BUGZILLA 9350): std.algorithm.findAdjacent unreachable code warning with infinite ranges)
$(LI $(BUGZILLA 9357): Floating-point literal should always be printed with a period in diagnostic errors)
$(LI $(BUGZILLA 9358): Compiler creates duplicate switch cases after an error)
$(LI $(BUGZILLA 9368): Final switch on typedef'ed enum is not properly checked)
$(LI $(BUGZILLA 9369): DDoc hardcodes '&' -> '&amp;' in code)
$(LI $(BUGZILLA 9374): 'super' should be accessible inside template constraint)
$(LI $(BUGZILLA 9398): Wrong diagnostic for ternary operator type mismatch)
$(LI $(BUGZILLA 9418): Segmentation fault using only datetime and stdio.)
$(LI $(BUGZILLA 9438): Strange RefCounted stack overflow)
$(LI $(BUGZILLA 9442): typeid$(LPAREN)$(RPAREN) doesn't work without `this.` for class fields)
$(LI $(BUGZILLA 9453): ice$(LPAREN)symbol.c$(RPAREN) with slice on temporary)
$(LI $(BUGZILLA 9458): ModExp generates invalid code against array operands)
$(LI $(BUGZILLA 9461): Ability to break typesystem with `inout`)
$(LI $(BUGZILLA 9479): _error_ in error message of type inference of a delegate literal)
$(LI $(BUGZILLA 9484): Syntax error in JSON output)
$(LI $(BUGZILLA 9510): core.bitop.bsr undefined)
)

)

$(BUGSTITLE DMD Compiler enhancements,

$(P
$(LI $(BUGZILLA 2630): ddoc should be able to document unittests)
$(LI $(BUGZILLA 3404): JSON output should retain original alias names)
$(LI $(BUGZILLA 4194): Attributes included in JSON output)
$(LI $(BUGZILLA 5529): std.system.endian for pure functions?)
$(LI $(BUGZILLA 5893): Allow simple aliases for operator overloading)
$(LI $(BUGZILLA 6171): rdmd: cache dependency file to improve startup time [patch])
$(LI $(BUGZILLA 8105): Implement "in ref")
$(LI $(BUGZILLA 8128): unittest blocks should be allowed in interfaces)
$(LI $(BUGZILLA 9389): ignore -Hd if -Hf is present)
$(LI $(BUGZILLA 9463): make @safe "non-escapable")
)

)

$(BUGSTITLE Phobos regressions,

$(P
$(LI $(BUGZILLA 9355): [security] SSL certificate signature verification disabled in std.net.curl)
$(LI $(BUGZILLA 9444): Regression $(LPAREN)2.059$(RPAREN): shell doesn't throw on error.)
$(LI $(BUGZILLA 9457): isSorted$(LPAREN)string$(RPAREN) doesn't work)
$(LI $(BUGZILLA 9523): std.conv.to will no longer convert enums to themselves)
)

)

$(BUGSTITLE Phobos bugs,

$(P
$(LI $(BUGZILLA 5065): writefln$(LPAREN)"%f"  of a Tuple prints a result)
$(LI $(BUGZILLA 5265): std.array.back does not work correctly for wchar-based arrays)
$(LI $(BUGZILLA 5726): boyerMooreFinder hangs when finding)
$(LI $(BUGZILLA 5763): traits.d BaseClassesTuple function incorrectly handles Object class argument)
$(LI $(BUGZILLA 5773): sort$(LPAREN)$(RPAREN) and topN$(LPAREN)$(RPAREN) fail on sliced/resized array of tuples)
$(LI $(BUGZILLA 6066): std.container: BinaryHeap interface is broken.)
$(LI $(BUGZILLA 6436): Refcounted initialization bug)
$(LI $(BUGZILLA 6635): std.conv.emplace: enforcement is too weak)
$(LI $(BUGZILLA 6668): Wrong "to" conversion stack trace)
$(LI $(BUGZILLA 7142): Wrong formatted write of boolean values)
$(LI $(BUGZILLA 7659): std.stdio.File.close$(LPAREN)$(RPAREN) erases file.name)
$(LI $(BUGZILLA 7819): std.file.setTimes throws error on folders)
$(LI $(BUGZILLA 8078): receiveOnly should tell which type it expected and got on mismatch)
$(LI $(BUGZILLA 8314): randomSample primes with constant)
$(LI $(BUGZILLA 8326): std.string.format results in run-time exception)
$(LI $(BUGZILLA 8367): std.range.chain's template constraint is inadequate)
$(LI $(BUGZILLA 8368): std.algorithm.sort's template constraint is inadequate)
$(LI $(BUGZILLA 8567): isDynamicArrray!S == true for S with alias this to array)
$(LI $(BUGZILLA 8689): Variant opArithmetic does not attempt float conversion)
$(LI $(BUGZILLA 8694): std.zlib.$(LPAREN)Un$(RPAREN)Compress can cause an _onInvalidMemoryOperationError)
$(LI $(BUGZILLA 8837): BigInt needs better operator template constraints)
$(LI $(BUGZILLA 8890): std.algorithm.commonPrefix does not handle unicode correctly)
$(LI $(BUGZILLA 8920): iota should work with all integral types)
$(LI $(BUGZILLA 9005): std.concurrency.spawn should allow `void delegate$(LPAREN)Args$(RPAREN) shared` for new Tid)
$(LI $(BUGZILLA 9163): std.parallelism broken with extensive optimizations $(LPAREN)gdc$(RPAREN))
$(LI $(BUGZILLA 9211): regex lookahead, $(LPAREN)?=$(LPAREN)\d\d\d$(RPAREN)+\b$(RPAREN) failed)
$(LI $(BUGZILLA 9288): Parameter$(LPAREN)Identifier|DefaultValue$(RPAREN)Tuple report pointless errors)
$(LI $(BUGZILLA 9299): std.algorithm.minPos of const$(LPAREN)int$(RPAREN)[])
$(LI $(BUGZILLA 9317): ParameterStorageClassTuple reports errors for inout function)
$(LI $(BUGZILLA 9336): Writeln is unable to print address of shared variable)
)

)

$(BUGSTITLE Phobos enhancements,

$(P
$(LI $(BUGZILLA 4287): opOpAssign!$(LPAREN)"~="$(RPAREN) for std.array.Appender)
$(LI $(BUGZILLA 4813): trait for getting at access modifiers)
$(LI $(BUGZILLA 5666): std.array.replace compile error $(LPAREN)string and immutable string$(RPAREN))
$(LI $(BUGZILLA 6614): std.traits should have an isFinal template)
$(LI $(BUGZILLA 7896): Sequence slicing)
$(LI $(BUGZILLA 8143): Safe std.conv.to enum conversion)
$(LI $(BUGZILLA 9337): There's no Duration.max)
$(LI $(BUGZILLA 9339): std.random.uniform!Enum should return random enum member)
)

)

$(BUGSTITLE Druntime bugs,

$(P
$(LI $(BUGZILLA 4793): Runtime.loadLibrary cannot load dll using MBS paths.)
$(LI $(BUGZILLA 5375): Detection of cyclic module imports provides error findings on console, instead of exception msg)
$(LI $(BUGZILLA 8132): LPTSTR always aliases to LPSTR)
$(LI $(BUGZILLA 9373): Add deprecation message to all empty deprecation statements)
)

)

$(BUGSTITLE Website regressions,

$(P
$(LI $(BUGZILLA 9467): Operator Overloading anchors are broken)
$(LI $(BUGZILLA 9492): [2.052 beta] Stylesheet not found for off-line HTML docs)
)

)

$(BUGSTITLE Website bugs,

$(P
$(LI $(BUGZILLA 5513): Erroneous example in std.algorithm)
$(LI $(BUGZILLA 7304): Online docs incorrect with regards to covariant arrays)
$(LI $(BUGZILLA 7345): interfaceToC.html missing on left-hand side)
$(LI $(BUGZILLA 8302): Documentation of dirEntries in std.file is incomplete)
$(LI $(BUGZILLA 8574): [std.format] The flag ' ' works for floating numbers, not only for integers)
$(LI $(BUGZILLA 8619): Tuples article uses writefln instead of writeln)
$(LI $(BUGZILLA 9321): Dead link to HTML5 standard in language specification)
$(LI $(BUGZILLA 9394): ABI for static arrays is outdated)
$(LI $(BUGZILLA 9446): ".keys" missing from properties table at http://dlang.org/hash-map.html)
$(LI $(BUGZILLA 9503): [grammar] template declaration/instance must take one or more arguments?)
)

)

$(BUGSTITLE Website enhancements,

$(P
$(LI $(BUGZILLA 9302): Document extern properly)
)
)

)

<div class="version">
$(UL
	$(NEW 062)
	$(NEW 061)
	$(NEW 060)
	$(NEW 059)
	$(NEW 058)
	$(NEW 057)
	$(NEW 056)
	$(NEW 055)
	$(NEW 054)
	$(NEW 053)
	$(NEW 052)
	$(NEW 051)
	$(NEW 050)
	$(NEW 049)
	$(NEW 048)
	$(NEW 047)
	$(NEW 046)
	$(NEW 045)
	$(NEW 044)
	$(NEW 043)
	$(NEW 042)
	$(NEW 041)
	$(NEW 040)
	$(NEW 039)
	$(NEW 038)
	$(NEW 037)
	$(NEW 036)
	$(NEW 035)
	$(NEW 034)
	$(NEW 033)
	$(NEW 032)
	$(NEW 031)
	$(NEW 030)
	$(NEW 029)
	$(NEW 028)
	$(NEW 027)
	$(NEW 026)
	$(NEW 025)
	$(NEW 023)
	$(NEW 022)
	$(NEW 021)
	$(NEW 020)
	$(NEW 019)
	$(NEW 018)
	$(NEW 017)
	$(NEW 016)
	$(NEW 015)
	$(NEW 014)
	$(NEW 013)
	$(NEW 012)
	$(NEW 011)
	$(NEW 010)
	$(NEW 009)
	$(NEW 008)
	$(NEW 007)
	$(NEW 006)
	$(NEW 005)
	$(NEW 004)
	$(NEW 003)
	$(NEW 002)
	$(NEW 001)
	$(NEW 000)

	$(LI $(LINK2 http://www.digitalmars.com/d/1.0/changelog.html, changelog for 1.0))

	$(COMMENT $(LI Download latest D 2.0 alpha
	 <a HREF="http://ftp.digitalmars.com/dmd.2.040.zip" title="download D compiler">
	 D compiler</a> for Win32 and x86 linux))

	$(LI $(LINK2 http://www.digitalmars.com/pnews/index.php?category=2, tech support))
)
</div>

$(VERSION 061, Jan 1, 2013, =================================================,

    $(WHATSNEW
	$(LI DMD now shows deprecated features as warnings by default (a
	     message is displayed but compilation is not halted anymore).
	     There are also 2 new compiler flags: -de, to get the old default
	     behaviour (using deprecated features is an error) and -dw, to
	     explicitly enable the new default behaviour (just warn).
	     This makes it possible to add -de in the configuration file to
	     get the old default and still be able to override that default
	     by using -dw when compiling.
	     The -d flag stays the same (silently ignore deprecated features).
	)
	$(LI Complete list of $(WHATSNEW2 2012-08-02, 2012-12-31))
    )
    $(BUGSFIXED
	$(LI $(DMDBUGSFIXED2 2012-08-02, 2013-01-01))
	$(LI $(DRUNTIMEBUGSFIXED2 2012-08-02, 2012-12-31))
	$(LI $(PHOBOSBUGSFIXED2 2012-08-02, 2012-12-31))
    )
$(COMMENT
    $(WHATSNEW
	$(LI $(BUGZILLA 1353): Can't use typeof() in base class list.)
	$(LI $(BUGZILLA 1427): Generated .di files look ugly and are hard to read)
	$(LI $(BUGZILLA 8108): Forward declaration and implementation allowed in same file)
	$(LI $(BUGZILLA 8794): DDoc should provide qualified symbol names suitable for anchors)
	$(LI $(BUGZILLA 9219): Allow matching { } in asm statements.)
	$(LI $(BUGZILLA 9221): Added -di flag to make use of deprecated symbols a warning)
	$(LI $(BUGZILLA 9222): Add User Defined Attributes)
	$(LI $(BUGZILLA 9223): Add -de and -dw switches)
	$(LI $(BUGZILLA 9224): Add Win64 code generation support for use with Visual C)
	$(LI $(BUGZILLA 9225): Add sections [Environment32] and [Environment64] to sc.ini/dmd.conf)
	$(LI $(BUGZILLA 9226): More simd instructions allowed as intrinsics.)
	$(LI $(BUGZILLA 9227): __traits(identifier,...) to pick out identifier from parameter list tuple)
	$(LI $(BUGZILLA 9228): Add getProtection to __traits())
    )
    $(RUNTIMEBUGSFIXED
	$(LI $(BUGZILLA 391): .sort and .reverse break utf8 encoding)
	$(LI $(BUGZILLA 8936): Throwing results in searching the whole directory tree rooted in current directory)
    )
    $(LIBBUGSFIXED
	$(LI $(BUGZILLA 9060): std.range.chain and std.range.zip cannot get frame pointer)
    )
    $(DMDBUGSFIXED
	$(LI $(BUGZILLA 2273): Whitespace is not inserted after commas)
	$(LI $(BUGZILLA 2775): "private" ignored for templates)
	$(LI $(BUGZILLA 2830): private attribute doesn't work for structs/unions/classes)
	$(LI $(BUGZILLA 4082): nothrow main() can throw)
	$(LI $(BUGZILLA 5448): Array of AAs literal doesn't work)
	$(LI $(BUGZILLA 5587): Use __LINE__ to pick number in unittest block names)
	$(LI $(BUGZILLA 5679): Type aliasing "this" from an access function defined in base class confuses the compiler about the type of objects)
	$(LI $(BUGZILLA 5832): Template alias parameters are never successfully pattern matched)
	$(LI $(BUGZILLA 5996): ICE(expression.c) CTFE of erroneous auto return function)
	$(LI $(BUGZILLA 6373): More descriptive 'hidden by X is deprecated' error)
	$(LI $(BUGZILLA 6395): ICE(glue.c) Multiple-at-a-time bug breaking e.g. DustMite)
	$(LI $(BUGZILLA 6937): new with struct doesn't allow field assignment)
	$(LI $(BUGZILLA 6969): Forward reference on template class triangle)
	$(LI $(BUGZILLA 7003): no tuple expansion for c++ mangling)
	$(LI $(BUGZILLA 7017): Pure inference makes inconsistent result)
	$(LI $(BUGZILLA 7192): improve error message for "object.d cannot be read")
	$(LI $(BUGZILLA 7220): Bad initialization when using mixin to generate a static field in a -lib'rary)
	$(LI $(BUGZILLA 7810): [CTFE] Typesafe variadic function with array of structs)
	$(LI $(BUGZILLA 7876): [CTFE] assertion failure on invalid stack reference)
	$(LI $(BUGZILLA 7940): CTFE wrong-code for opAssign and std.array.Appender)
	$(LI $(BUGZILLA 7998): static assert message string printing problem)
	$(LI $(BUGZILLA 8178): Wrong line number in trying to modify enum string)
	$(LI $(BUGZILLA 8257): __traits(compiles) gives compile error)
	$(LI $(BUGZILLA 8271): [Ddoc] non-ascii character string macro names cannot be replaced)
	$(LI $(BUGZILLA 8339): is(typeof(...)) is reporting true when it's false due to nested function error)
	$(LI $(BUGZILLA 8376): 64 bit codegen bug involving dynamically indexed static array and continue statement)
	$(LI $(BUGZILLA 8377): Unexpected OPTLINK Termination at EIP=004106BE)
	$(LI $(BUGZILLA 8340): *= operator breaks long array in x64)
	$(LI $(BUGZILLA 8348): ICE(glue.c): 'semanticRun == PASSsemantic3done' on line 547 in file 'glue.c')
	$(LI $(BUGZILLA 8422): [CTFE] TypeTuple of tuples can't be read at compile time)
	$(LI $(BUGZILLA 8408): Purity calculation should be improved)
	$(LI $(BUGZILLA 8484): [CTFE] Assertion failure: 'thisval && thisval->op == TOKclassreference' on line 4896 in file 'interpret.c'.)
	$(LI $(BUGZILLA 8497): Regression 2.060: Bad code gen involving ubyte, ternary operators, and shifts)
	$(LI $(BUGZILLA 8519): winsamp.d doesn't compile with 2.060)
	$(LI $(BUGZILLA 8556): Using take results in a corrupted call to opSlice)
	$(LI $(BUGZILLA 8601): CTFE Assertion failure (interpret.c) on dstring[].toUpper)
	$(LI $(BUGZILLA 8623): Multiple function match needs to print file+line numbers)
	$(LI $(BUGZILLA 8624): Regression: CTFE: long comparisons completely broken)
	$(LI $(BUGZILLA 8630): Assertion failure: 'fd && fd->inferRetType' on line 81 in file 'mangle.c')
	$(LI $(BUGZILLA 8644): CTFE doesn't support string $(LESS),$(GREATER) on array literals)
	$(LI $(BUGZILLA 8673): enum z = [0][(()=>$-1)()]; crashes the compiler)
	$(LI $(BUGZILLA 8675): Nothrow can't throw Errors)
	$(LI $(BUGZILLA 8714): Missing error message with circular use of CTFE)
	$(LI $(BUGZILLA 8770): Wrong error line number with immutable field)
	$(LI $(BUGZILLA 8774): 2.059 worked 2.060 does not: nested delegate memory corruption)
	$(LI $(BUGZILLA 8788): The super constructor call can be prevented by mentioning "return".)
	$(LI $(BUGZILLA 8796): Optimizer bug on 64bit: *p++=1 where p is a parameter)
	$(LI $(BUGZILLA 8801): assigning to __ctfe crashes the compiler)
	$(LI $(BUGZILLA 8818): CTFE fails to compare strings correctly)
	$(LI $(BUGZILLA 8830): [CTFE] Incorrect slicing with pointer from sliced array)
	$(LI $(BUGZILLA 8836): function called with argument types ((void function())) matches both f(void function() fn) and f(void delegate() dg))
	$(LI $(BUGZILLA 8840): calculating minimum of longs with following comparison compiles to wrong code when enabling the optimizer)
	$(LI $(BUGZILLA 8857): [CTFE] does not evaluate to a boolean, only with -inline)
	$(LI $(BUGZILLA 8870): Incorrect values passing struct by value)
	$(LI $(BUGZILLA 8889): [2.061 beta][64-bit] Assertion Failure argtypes.c)
	$(LI $(BUGZILLA 8894): 2.059: Lookup error message has become uninformative)
	$(LI $(BUGZILLA 8923): Destructors of struct members get called at the wrong point)
	$(LI $(BUGZILLA 8928): Poor error message for derived class without constructor)
	$(LI $(BUGZILLA 8939): ICE(glue.c) on passing by ref statically initialized const/immutable variable)
	$(LI $(BUGZILLA 8940): Able to modify const/immutable with passing to a templated function by `ref`)
	$(LI $(BUGZILLA 8942): `alias <qualifier> <type>` ignores <qualifier> in foreach over tuple)
	$(LI $(BUGZILLA 8943): Cannot get parent of an overload)
	$(LI $(BUGZILLA 8966): ICE(cgcod.c) when passing cfloat argument with indirection)
	$(LI $(BUGZILLA 8971): __traits(getOverloads) fails in a member function)
	$(LI $(BUGZILLA 8986): The PVS-Studio analyzer has something for you)
	$(LI $(BUGZILLA 8990): Forward reference error on three structs)
	$(LI $(BUGZILLA 8937): import declaration statement without scope after `if` imports to a parent scope)
	$(LI $(BUGZILLA 8987): Compiling using -O -release options yield Internal error: backend\cgcod.c 1663)
	$(LI $(BUGZILLA 9000): ICE on assigning struct's `init` to enum)
	$(LI $(BUGZILLA 9003): Nested structs smetimes have null context pointers in static struct)
	$(LI $(BUGZILLA 9004): Wrong line number for undefined identifier error)
	$(LI $(BUGZILLA 9006): Static struct with nested struct fields sometimes has current context pointers in `init`)
	$(LI $(BUGZILLA 9008): Another forward referencing bug)
	$(LI $(BUGZILLA 9010): opEquals() const results in not-covered code)
	$(LI $(BUGZILLA 9013): Compiler crash with foreach on wrongly defined interval)
	$(LI $(BUGZILLA 9025): core.thread.Fiber seems to crash on Win64)
	$(LI $(BUGZILLA 9026): Template mixin identifier as template alias parameter doesn't work)
	$(LI $(BUGZILLA 9035): Nested struct `init` is lvalue and can be modified)
	$(LI $(BUGZILLA 9036): postblit is called for nested structs when assigning `init`)
	$(LI $(BUGZILLA 9046): typeof(T.init) should have the type T)
	$(LI $(BUGZILLA 9057): Regression(Beta): Segfault or 'Non-constant expression' error with local import)
	$(LI $(BUGZILLA 9058): Problem with std.traits.EnumMembers conversion to array)
	$(LI $(BUGZILLA 9069): struct literals are treated as lvalues)
	$(LI $(BUGZILLA 9070): nothrow of constructer/destructor isn't correct)
	$(LI $(BUGZILLA 9076): Aliased template function and property resolution doesn't work)
	$(LI $(BUGZILLA 9077): Struct copy constructor ignored when opAssign with a different type is present)
	$(LI $(BUGZILLA 9090): auto ref doesn't work with arrays)
	$(LI $(BUGZILLA 9093): Overloads in extern(C++) interfaces throw up COMDAT errors)
	$(LI $(BUGZILLA 9100): Weird behavior on template instance argument)
	$(LI $(BUGZILLA 9124): Object variable of variadic template struct needs explicit "this" in certain situations)
	$(LI $(BUGZILLA 9140): ref foreach of immutables in postcondition)
	$(LI $(BUGZILLA 9143): template structs with two parameters confuse DMD on multiple instantiations)
	$(LI $(BUGZILLA 9153): Type inference for array of delegates should not break based on order)
	$(LI $(BUGZILLA 9154): Incorrectly generated assignment operator)
	$(LI $(BUGZILLA 9162): [tdpl] Non-static structs should have access to outer lexical scope)
	$(LI $(BUGZILLA 9170): CTFE: Allow reinterpret casts float $(LESS)-$(GREATER) int)
	$(LI $(BUGZILLA 9171): error optimization of expression)
	$(LI $(BUGZILLA 9210): [2.061 beta] Import cycle causes unpredictable compile errors)
	$(LI $(BUGZILLA 9213): [2.061 beta] Member access without this and __traits(compiles, ...))
    )
)
)

$(VERSION 060, Aug 2, 2012, =================================================,

    $(WHATSNEW
        $(LI std.string: $(RED The current implementations of std.string.format and string.sformat are
             scheduled to be replaced in November 2012 with improved implementations
             which conform to writef. In some, rare cases, this will break code.
             Please see the documentation for std.string.format and std.string.sformat for details.))
        $(LI std.bitmanip: Added peek, read, write, and append for converting
             ranges of bytes to and from integral types.)
        $(LI std.container: Added DList, which is an implementation of a doubly-linked list.)
        $(LI Added std.file.tempDir which returns the path to a directory
             where a program can put temporary files.)
        $(LI std.process: Added escapeShellCommand, escapeShellFileName, and
             escapeWindowsArgument. Documented browse function.)
        $(LI std.range: Added RefRange, which effectively makes it possible to
             pass a range by reference.)
        $(LI std.traits: Added KeyType, ValueType, isScalarType, isBasicType, and
             SetFunctionAttributes templates.)
        $(LI std.utf: Added overload of codeLength which operates on a string.)
        $(LI std.traits: areAllSafe has been scheduled for deprecation. Please use
             allSatisfy(isSafe, ...) instead.)
        $(LI clear has been renamed to destroy, and clear (as an alias to destroy) has
             been scheduled for deprpecation.)
        $(LI Capitalized std.traits.pointerTarget to PointerTarget. Old one is
             scheduled for deprecation.)
        $(LI std.algorithm.indexOf - which was scheduled for deprecation - has been deprecated (it was
             easily confused with std.string.indexOf). Please use countUntil instead.)
        $(LI std.cpuid - which was scheduled for deprecation - has been deprecated.
             Please use core.cpuid instead.)
        $(LI std.conv.ConvError and ConvOverflowException - which were scheduled for deprecation - have
             been deprecated. Please catch ConvException and ConvOverflowException instead.)
        $(LI The overloads of std.conv.to which were scheduled for deprecation
             because formattedWrite replaced them have now been deprecated.
             Please use std.format.formattedWrite instead.)
        $(LI The overload of std.exception.enforce which takes the file and line number as template
             arguments has been scheduled for deprecation (as it causes unnecessary template bloat).
             Please use the overload which takes them as function arguments instead. This will have no
             effect on any calls to enforce which do not explicitly pass the file or line number.)
        $(LI std.format.FormatError - which was scheduled for deprecation - has been deprecated.
             Please catch FormatException instead.)
        $(LI std.file.listDir has been deprecated. Please use std.file.dirEntries instead.)
        $(LI std.range.replicate - which was scheduled for deprecation - has been deprecated.
             Please use repeat instead.)
        $(LI std.range.SortedRange.canFind - which was scheduled for deprecation - has been deprecated.
             Please use SortedRange.contains instead.)
        $(LI std.socket: timeval and linger - which were scheduled for deprecation - have been deprecated.
             Please use TimeVal and Linger.)
        $(LI std.stdio.isStreamingDevice has been scheduled for deprecation. Please use
             isFileHandle instead.)
        $(LI The deprecated std.typecons.defineEnum has been removed.)
        $(LI UtfException - which was scheduled for deprecation - has been deprecated.
             Please use UTFException instead.)
        $(LI The deprecated overloads of std.array.insert and std.array.replace
             have been removed. Please use insertInPlace and replaceInPlace instead.)
        $(LI The deprecated toISOExtendedString and fromISOExtendedString
             functions in std.datetime have been removed. Please use
             toISOExtString and fromISOExtString instead.)
        $(LI The deprecated std.file.getTimesPosix has been removed.
             Please use std.file.getTimes instead.)
        $(LI The deprecated overloads of isFile, isDir, and isSymLink in
             std.file which took uint have been removed. Please use
             attrIsFile, attrIsDir, and attrIsSymlink instead.)
        $(LI The deprecated std.file.DirEntry.timeStatusChanged has been removed.
             Please use std.file.DirEntry.attributes to get at that information
             if you need it.)
        $(LI The deprecated std.contracts module has been removed. Please use
             std.exception instead.)
        $(LI The deprecated std.arg, std.bind, and std.loader modules have been
             removed.)

	$(LI Added TypeInfo.rtInfo property to get library defined runtime info.)
	$(LI Added front end support for AVX 256 bit SIMD instructions.)
	$(LI Default arguments and parameter identifiers (if any) are added to the tuple generated from
	IsExpression's __parameters case.)
	$(LI Changed the way the align attribute works, to make it more usable and comprehensible.
	Default alignment has not changed.)
	$(LI The align attribute now accepts arbitrary powers of two. This affects layout
	of static data, too. Such effects are dependent on limitations of the object file format -
	currently Win32 programs cannot align on larger than 16 byte boundaries.)
	$(LI HTML input file support completely removed.)
	$(LI $(BUGZILLA 3150): cast from dynamic array to ulong is allowed)
	$(LI $(BUGZILLA 3866): anonymous delegate with default parameters cross-talks to another anonymous delegate)
	$(LI $(BUGZILLA 4174): Template interface functions not allowed, making operator overloads difficult)
	$(LI $(BUGZILLA 6652): 1. Warn modifying non ref variable if -w is specified.)
	$(LI $(BUGZILLA 7243): Compiler should call separate function when allocating a struct on the heap)
	$(LI $(BUGZILLA 7923): Please remove 'deprecated' from setAssertHandler())
	$(LI $(BUGZILLA 8105): in ref)
	$(LI $(BUGZILLA 8127): dmd link library paths not given precedence over gcc defaults)
	$(LI $(BUGZILLA 8221): typeof(null) rejected as return type for covariant overrides)
    )
    $(RUNTIMEBUGSFIXED
	$(LI $(BUGZILLA 6909): incorrect definition of the OVERLAPPED struct in core.sys.windows.windows ?)
    )
    $(LIBBUGSFIXED
        $(LI $(BUGZILLA 2328): setTypeInfo in gc.d backwards.)
        $(LI $(BUGZILLA 2588): std.signals should not use 'length' stealth keyword in indexing)
        $(LI $(BUGZILLA 4405): all function - returns whether predicate is true for all elements in a range)
        $(LI $(BUGZILLA 4603): array(iota(1, 0))  error)
        $(LI $(BUGZILLA 4605): Wrong print of an int[string] aa)
        $(LI $(BUGZILLA 4629): BufferedFile.printf() wants char[] as first argument)
        $(LI $(BUGZILLA 4695): std.range.zip is broken)
        $(LI $(BUGZILLA 4744): std.conv: string-&gt;enum doesn't look for longer match)
        $(LI $(BUGZILLA 4822): Problem with std.stdio.File.writef(&quot;%c&quot;)
        $(LI $(BUGZILLA 5011): std.container: SList linearRemove produces wrong results)
        $(LI $(BUGZILLA 5089): feqrel does not compile for floats)
        $(LI $(BUGZILLA 5260): std.math.feqrel() returns negative number)
        $(LI $(BUGZILLA 5346): instantiation of std.conv.toImpl and std.format.formatValue fails for unions)
        $(LI $(BUGZILLA 5354): formatValue: range templates introduce 3 bugs related to class &amp; struct cases)
        $(LI $(BUGZILLA 5786): std.algorithm.sort does not work with std.container.Array: Range violation)
        $(LI $(BUGZILLA 5843): Unable to convert a struct with an alias-this to long/ulong to int, using std.conv.to!int.)
        $(LI $(BUGZILLA 5970): fix BigInt.toString)
        $(LI $(BUGZILLA 6027): bigint to!string conversion and its implications)
        $(LI $(BUGZILLA 6175): String corruption when passing static char arrays to std.conv)
        $(LI $(BUGZILLA 6191): removechars doesn't accept a const string)
        $(LI $(BUGZILLA 6197): std.traits.isImplicitlyConvertible returns some wrong results.)
        $(LI $(BUGZILLA 6222): A problem with iota() using size_t)
        $(LI $(BUGZILLA 6231): [patch] std.conv.to/std.format.: Structs with toString and isInputRange match multiple templates.)
        $(LI $(BUGZILLA 6273): Tuple [] operator in pure function)
        $(LI $(BUGZILLA 6379): std.container.SList fails to compile)
        $(LI $(BUGZILLA 6437): Refcounted calls dtor before ctor, never calls dtor for globals)
        $(LI $(BUGZILLA 6547): Call to std.algorithm.remove causes compile error)
        $(LI $(BUGZILLA 6580): scoped classes are aligned incorrectly)
        $(LI $(BUGZILLA 6597): to!SomeString should use std.format.formatValue)
        $(LI $(BUGZILLA 6642): SysTime should not be hasUnsharedAliasing)
        $(LI $(BUGZILLA 6892): Formatted write with specified length of enum member)
        $(LI $(BUGZILLA 6926): std.process.system return wrong exit code)
        $(LI $(BUGZILLA 7022): File.byLine doesn't release file handle)
        $(LI $(BUGZILLA 7138): Can't call array() on dirEntries)
        $(LI $(BUGZILLA 7317): writeln cannot handle alias this of array type)
        $(LI $(BUGZILLA 7326): write interprets enum with byte backing type as a character)
        $(LI $(BUGZILLA 7348): to!string(null) matches more than one template declaration)
        $(LI $(BUGZILLA 7356): Implement KeyType, ValueType for hashes in std.traits)
        $(LI $(BUGZILLA 7360): Predicate templates in std.traits should consider alias this)
        $(LI $(BUGZILLA 7515): The new std.string.translate is slow for ASCII text)
        $(LI $(BUGZILLA 7537): `File.tmpfile` requires administrator rights on Windows)
        $(LI $(BUGZILLA 7561): std.net.curl broken)
        $(LI $(BUGZILLA 7660): toImpl conflict in std.conv)
        $(LI $(BUGZILLA 7796): std.typecons.Unique is using writeln without importing std.stdio)
        $(LI $(BUGZILLA 7824): isInputRange fails to recognize inout(T)[])
        $(LI $(BUGZILLA 7831): Unlisted @@@BUG in File.detach causes FILE* leaks when reopening)
        $(LI $(BUGZILLA 7878): A problem with purity and general templated algorithms)
        $(LI $(BUGZILLA 7898): [CTFE] std.algorithm:copy fails when used with two arrays)
        $(LI $(BUGZILLA 7909): to!(enum)(string) and to!(string)(enum) break when enum is integral)
        $(LI $(BUGZILLA 7919): Sample code works on GDC but fails with DMD)
        $(LI $(BUGZILLA 7936): std.random.randomSample always returns the same first value when passed a random number generator)
        $(LI $(BUGZILLA 7937): Range iota.Result should be const where possible)
        $(LI $(BUGZILLA 7944): std.range.iota.popFront() cycles when the range is empty)
        $(LI $(BUGZILLA 7948): std.range.zip broken with requireSameLength)
        $(LI $(BUGZILLA 7962): std.regex: Captures.length() returns incorrect value)
        $(LI $(BUGZILLA 7973): BigInt %= long/ulong gives wrong value)
        $(LI $(BUGZILLA 7975): Incorrect quotes escaping in std.format)
        $(LI $(BUGZILLA 7982): iota broken when start and end are unsigned and step is negative.)
        $(LI $(BUGZILLA 7993): BigInt divide-by-1 error)
        $(LI $(BUGZILLA 8003): Phobos uses deprecated std.path sep symbol)
        $(LI $(BUGZILLA 8011): BigInt ++ and -- do wrong thing on negative numbers)
        $(LI $(BUGZILLA 8015): std.typecons.Tuple does not support struct with alias method this)
        $(LI $(BUGZILLA 8022): BigInt division bug (2))
        $(LI $(BUGZILLA 8026): Fix or disallow randomShuffle() on fixed-sized arrays)
        $(LI $(BUGZILLA 8031): If a class have some signals it's impossible for a derived class to have any signals)
        $(LI $(BUGZILLA 8037): hasElaborateDestructor is false for non-zero-length static array of structs with elaborate destructor)
        $(LI $(BUGZILLA 8039): `scoped` doesn't call any elaborate destructors for struct fields)
        $(LI $(BUGZILLA 8040): writeln(null) too)
        $(LI $(BUGZILLA 8055): [Regression 2.059] std.algorithm.move corrupts moved object field)
        $(LI $(BUGZILLA 8057): std.algorithm.move cannot use for nested struct)
        $(LI $(BUGZILLA 8080): 'alias this' causes toString to be shadowed by aliased object)
        $(LI $(BUGZILLA 8112): std.algorithm.fill must accept InputRange)
        $(LI $(BUGZILLA 8158): std.algorithm.min fails to compile with user-defined types)
        $(LI $(BUGZILLA 8164): BigInt from char[] too)
        $(LI $(BUGZILLA 8165): BigInt opAssign return value)
        $(LI $(BUGZILLA 8171): [Regression 2.060head] Broken std.algorithm.move for nested struct has no member)
        $(LI $(BUGZILLA 8186): Formatting class object has an alias this to int* field is broken.)
        $(LI $(BUGZILLA 8187): replaceFirst doesn't work for string[] haystack)
        $(LI $(BUGZILLA 8191): cstream.printf is completely unusable on x86_64)
        $(LI $(BUGZILLA 8195): Segfault when comparing a VariantN to a non-variant type which it holds)
        $(LI $(BUGZILLA 8203): Use of std.regex.match() generates &quot;not enough preallocated memory&quot; error)
        $(LI $(BUGZILLA 8214): blocking option for TaskPool.finish())
        $(LI $(BUGZILLA 8233): std.array.array fails to compile with ranges of immutable elements which have a length property)
        $(LI $(BUGZILLA 8240): std.algorithm.joiner and empty inputRangeObject)
        $(LI $(BUGZILLA 8264): [std.conv.to] constructing conversion doesn't work with alias this)
        $(LI $(BUGZILLA 8310): writeln of Range of fixed size array)
        $(LI $(BUGZILLA 8323): std.string.chompPrefix does not handle differing string types properly)
        $(LI $(BUGZILLA 8362): std.traits.isSafe doesn't work with unsafe lamdba functions)
        $(LI $(BUGZILLA 8386): writeln stopped working with wstring)
        $(LI $(BUGZILLA 8398): enforceEx cannot be used with OutOfMemoryError)
        $(LI $(BUGZILLA 8450):  std.traits.isSafe doesn't work with unsafe lamdba functions)
    ))
    $(DMDBUGSFIXED
	$(LI $(BUGZILLA 1175): nested class inheritance)
	$(LI $(BUGZILLA 1780): Type tuple deduction failure for class templates)
	$(LI $(BUGZILLA 2472): Delegates are not lvalue.)
	$(LI $(BUGZILLA 2962): ICE(glue.c) or bad codegen passing variable as template value parameter)
	$(LI $(BUGZILLA 3290): accepts-invalid: non-const by-ref foreach over a const array is accepted)
	$(LI $(BUGZILLA 3574): post-condition in void main() is not evaluated if there is no return statement)
	$(LI $(BUGZILLA 3608): Allow isExpression and templates to capture template parameters and FQN of template)
	$(LI $(BUGZILLA 3703): static array assignment)
	$(LI $(BUGZILLA 3895): Appending a double[] to a float[] generates wrong code)
	$(LI $(BUGZILLA 4024): Last catch only accepts block statement)
	$(LI $(BUGZILLA 4155): return of NaN to temporary fails equality test)
	$(LI $(BUGZILLA 4288): Error on passing delegate to C linkage function)
	$(LI $(BUGZILLA 4364): ICE(class.c) compiling a struct def named 'Object' followed by a class definition)
	$(LI $(BUGZILLA 4510): [tdpl] ref with a wrong type specifier is accepted)
	$(LI $(BUGZILLA 4583): PIC code not working: EBX register set incorrectly)
	$(LI $(BUGZILLA 4785): auto return of a function with in contract)
	$(LI $(BUGZILLA 4884): Using template struct parameters in method definition fails with "parameter _param_0 is already defined")
	$(LI $(BUGZILLA 4953): Regression(2.031): templates don't do implicit conversion properly)
	$(LI $(BUGZILLA 4967): member default initializers not working in static struct initializers)
	$(LI $(BUGZILLA 5039): Cannot use invariant() with auto methods)
	$(LI $(BUGZILLA 5082): delegate alias parameters are silently accepted inside structs. limits most of std.algorithm, etc.)
	$(LI $(BUGZILLA 5435): Static foreach over tuple ignores type annotation)
	$(LI $(BUGZILLA 5437): Problems with length of std.traits.EnumMembers)
	$(LI $(BUGZILLA 5473): Members of const-qualified classes are not const themselves.)
	$(LI $(BUGZILLA 5737): postblit not called for locals initialized from ref functions)
	$(LI $(BUGZILLA 5809): [64 bit] wrong code for *p==0, when widening conversion occurs)
	$(LI $(BUGZILLA 5896): const overload matching is succumb to template parameter one)
	$(LI $(BUGZILLA 6189): [64bit] optimizer: register content destroyed in function prolog)
	$(LI $(BUGZILLA 6199): [GSoC] Postblit not called when returning a reference to a by-value function)
	$(LI $(BUGZILLA 6470): postblits not called on arrays of structs)
	$(LI $(BUGZILLA 6475): template identifier is not a member of alias)
	$(LI $(BUGZILLA 6591): di header generation loses selective import symbols)
	$(LI $(BUGZILLA 6612): Associative arrays with associative array keys literals)
	$(LI $(BUGZILLA 6636): Destructors of static array elements are not called on function parameter)
	$(LI $(BUGZILLA 6637): Postblits of static array elements are not called on function argument)
	$(LI $(BUGZILLA 6758): std.c.stdarg problems with 8 or more integer arguments on x86_64)
	$(LI $(BUGZILLA 6891): template with uint value parameter causes several issues)
	$(LI $(BUGZILLA 7396): Indicate default alignment with 0.)
	$(LI $(BUGZILLA 7385): Bad error message missing line number on invalid array op that isn't special cased)
	$(LI $(BUGZILLA 7413): Vector literals don't work)
	$(LI $(BUGZILLA 7414): Vector literal assignment doesn't work in global scope)
	$(LI $(BUGZILLA 7418): Overloading doesn't work with aliases declared inside templates)
	$(LI $(BUGZILLA 7453): Can't return value from within opApply)
	$(LI $(BUGZILLA 7478): stack overflow compiling with -deps -release -inline -noboundscheck)
	$(LI $(BUGZILLA 7494): Selective import does not work inside a function)
	$(LI $(BUGZILLA 7506): Postblit does not called properly with inlining)
	$(LI $(BUGZILLA 7530): Postblit not called structs returned from an array index expr.)
	$(LI $(BUGZILLA 7560): Base class overloaded methods created by mixins can't be overriden)
	$(LI $(BUGZILLA 7581): Compiler uses wrong instructions to move complex value from ST to xmm registers)
	$(LI $(BUGZILLA 7585): functions in templates inferred as delegate)
	$(LI $(BUGZILLA 7750): while(true) loop with try/catch block causes segfault)
	$(LI $(BUGZILLA 7770): __dollar cannot be read at compile time)
	$(LI $(BUGZILLA 7784): ICE with self-referencing literals)
	$(LI $(BUGZILLA 7793): static assert( void_function() ) gives misleading error message)
	$(LI $(BUGZILLA 7807): Ambiguous virtual function error on const overloading with covariant return types)
	$(LI $(BUGZILLA 7851): Internal error: e2ir.c 688)
	$(LI $(BUGZILLA 7880): [CTFE] cast from void array allowed with different results than at runtime)
	$(LI $(BUGZILLA 7893): Spec completely wrong for D variadic arguments on 64 bits)
	$(LI $(BUGZILLA 7894): [CTFE] - goto within ForStatement restarts loop)
	$(LI $(BUGZILLA 7906): [ICE] enum declaration with invalid array literal crashes dmd)
	$(LI $(BUGZILLA 7907): [ICE] invalid expression on template argument crashes dmd)
	$(LI $(BUGZILLA 7911): Nested static if failing to execute)
	$(LI $(BUGZILLA 7922): alias this causes weird formatting issues for strings)
	$(LI $(BUGZILLA 7929): Broken semantic of StructInitializer with const)
	$(LI $(BUGZILLA 7931): Error message with _error_ with var[1,2])
	$(LI $(BUGZILLA 7932): Corrupted argument inside out contract in x86_64)
	$(LI $(BUGZILLA 7933): Illegal interaction of templates)
	$(LI $(BUGZILLA 7941): Regression(2.059): Type check is ignored when manifest constant initializer is function literal)
	$(LI $(BUGZILLA 7943): UFCS does not work with alias this)
	$(LI $(BUGZILLA 7945): alias this doesn't work on function ref parameter)
	$(LI $(BUGZILLA 7949): [ICE] (cgcod.c) with SIMD array)
	$(LI $(BUGZILLA 7950): Type tuples are incorrectly flattened in base type list of interface)
	$(LI $(BUGZILLA 7951): DMD: Internal error: backend/cgxmm.c 567)
	$(LI $(BUGZILLA 7965): Invalid outer function scope pointer in some cases)
	$(LI $(BUGZILLA 7974): forward reference of mixin declaration)
	$(LI $(BUGZILLA 7983): ICE with getMember on a unittest member)
	$(LI $(BUGZILLA 7987): [CTFE] cannot compare arrays of slices)
	$(LI $(BUGZILLA 8002): Excess initial errors when passing template args to non-templated struct)
	$(LI $(BUGZILLA 8004): Direct call of function literal should consider default arguments)
	$(LI $(BUGZILLA 8005): Lambda with parameter type inference should consider default args)
	$(LI $(BUGZILLA 8016): Methods defined in external object files when template alias parameter is involved)
	$(LI $(BUGZILLA 8032): `mixin template` before virtual method with same method causes an error)
	$(LI $(BUGZILLA 8036): Zero-length static array of structs with elaborate destructor as struct or class field is rejected)
	$(LI $(BUGZILLA 8038): #line which is in a double template instantiation doesn't work)
	$(LI $(BUGZILLA 8060): xmmstore cannot allocate store for optimized operation that uses int and floats)
	$(LI $(BUGZILLA 8064): return reference semantics not obeyed on delegates?)
	$(LI $(BUGZILLA 8066): ICE on missing return statement if invariant is present)
	$(LI $(BUGZILLA 8069): incorrect ambiguous virtual function error)
	$(LI $(BUGZILLA 8073): Regression (git) Error: undefined identifier __result)
	$(LI $(BUGZILLA 8089): Importing package as module causes segfault)
	$(LI $(BUGZILLA 8091): Optimizer generates wrong code when reducing comparisons)
	$(LI $(BUGZILLA 8094): Static if matching using alias parameter in template fails)
	$(LI $(BUGZILLA 8095): [64 bit] Wrong code generation with spilled register, -m64 -O)
	$(LI $(BUGZILLA 8098): Inner class method can modify outer's members regardless of constancy)
	$(LI $(BUGZILLA 8099): Inner class's outer pointer matches constancy of inner, but can be set to object of arbitrary constancy)
	$(LI $(BUGZILLA 8182): with a lazy struct parameter, the struct's destructor is called on the generated delegate)
	$(LI $(BUGZILLA 8180): UFCS writeln doesn't work with Tuples)
	$(LI $(BUGZILLA 8113): alias this doesn't forward opCall)
	$(LI $(BUGZILLA 8123): alias declaration lookup is broken)
	$(LI $(BUGZILLA 8125): TypeInstance dedunction problem)
	$(LI $(BUGZILLA 8129): Cannot deduce template function when using partially specified type in function parameter)
	$(LI $(BUGZILLA 8147): Blah!R.init now requires parens - (Blah!R).init)
	$(LI $(BUGZILLA 8168): dmd crashes when asm statement with wrong opcode)
	$(LI $(BUGZILLA 8169): Method loses its compile-time evaluability when used through alias this)
	$(LI $(BUGZILLA 8185): Pure functions and pointers)
	$(LI $(BUGZILLA 8188): need this to access member when mixining in a function)
	$(LI $(BUGZILLA 8190): Externally defined struct error message)
	$(LI $(BUGZILLA 8194): "Function cannot access frame" even though all I requested was the type)
	$(LI $(BUGZILLA 8198): Nested lambda inference doesn't work)
	$(LI $(BUGZILLA 8199): stack is not aligned in finally block)
	$(LI $(BUGZILLA 8212): shared value data structures should implicitly cast to mutable)
	$(LI $(BUGZILLA 8216): CTFE should allow 'pointer is inside range' comparisons)
	$(LI $(BUGZILLA 8226): Global lambda assign to const/immutable)
	$(LI $(BUGZILLA 8237): Error message with _error_ when using failed type inference in template parameter)
	$(LI $(BUGZILLA 8241): cannot use template function literal as default alias argument)
	$(LI $(BUGZILLA 8242): cannot use template function literals at module scope)
	$(LI $(BUGZILLA 8249): Spurious error message with templates and alias this)
	$(LI $(BUGZILLA 8252): no UFCS for 0 literal)
	$(LI $(BUGZILLA 8276): [CTFE] ICE when reading variable from nested function)
	$(LI $(BUGZILLA 8283): ICE(cod1.c): returning struct with constructor as member of another struct)
	$(LI $(BUGZILLA 8315): Invalid nested-ref check in template constraint)
	$(LI $(BUGZILLA 8335): `ref` is ignored for static array of stucts with postblit argument)
	$(LI $(BUGZILLA 8390): Refused array operation mutable[] += const[])
	$(LI $(BUGZILLA 8397): parameter types are not checked when assigning a function literal)
	$(LI $(BUGZILLA 8423): Wrong code for bool parameter in 5th integer register.)
	$(LI $(BUGZILLA 8429): [2.060 beta] 'version' rejected inside 'static if's)
	$(LI $(BUGZILLA 8434): [Regression 2.058] cannot implicitly convert expression (vs1.opCast()) of type const(Vector2D) to object.Object)
	$(LI $(BUGZILLA 8437): [2.060 beta] static struct no size yet for forward reference)
	$(LI $(BUGZILLA 8442): [2.060 beta] Empty array enum not treated as immutable)
	$(LI $(BUGZILLA 8453): Associative array keys refused as property by sort)
	$(LI $(BUGZILLA 8454): [ICE] (backend\cg87.c 3497) with cdouble and sqrt)
    )
)

$(VERSION 059, Apr 12, 2012, =================================================,

    $(WHATSNEW
	$(LI Add predefined Ddoc macro SRCFILENAME)
	$(LI Changed lexer to support # as a token, preserving #line's original behavior)
	$(LI added AES, PCLMULQDQ, RDRAND, AVX, VAES, VPCLMULQDQ, FMA, FP16C to core.cpuid)
	$(LI $(BUGZILLA 435): Constructors should be templatized)
	$(LI $(BUGZILLA 2367): Overloading error with string literals)
	$(LI $(BUGZILLA 3382): [tdpl] Implement uniform function call syntax)
	$(LI $(BUGZILLA 4536): Typetuples (T...) should have an .init member)
	$(LI $(BUGZILLA 5525): Eponymous templates should allow for overloaded eponymous members)
	$(LI $(BUGZILLA 7105): relax inout rules)
	$(LI $(BUGZILLA 7833): Changelog should clearly mention struct literal/opCmp/opEquals/toHash changes)

	$(LI Strive to make toHash, toString, opEquals and opCmp functions pure, nothrow,
	const and @safe. Soon, this will become a requirement.)

        $(LI The deprecated std.date, std.dateparse, and std.gregorian modules
             have been removed. Please use std.datetime instead.)
        $(LI Several deprecated functions in std.file have been removed.)
        $(LI The old functions in std.path which were scheduled for deprecation
             have now been deprecated. Please use the new ones which were
             introduced in 2.055. However, note that curdir and pardir do not
             have replacements, because they're "." and ".." respectively on all
             OSes so variables for them were seen as unnecessary. Also, one major
             change to note about the new std.path functions is that when operating
             on extensions, they expect "." to be part of the extension whereas the
             old ones did not (e.g. "file.txt".extension == ".txt" whereas
             "file.txt".getExt() == "txt").)
        $(LI The version of std.exception.enforceEx which was scheduled for
             deprecation has been deprecated. Please use the version which
             takes exceptions which can be constructed with new E(msg, file, line)
             (rather than just new E(msg) as the old version did). That way,
             exceptions constructed with enforceEx will give the file and line
             number where enforceEx was called.)
        $(LI Get rid of Win9x support.)
        $(LI std.typecons: Added Proxy mixin template.)
        $(LI std.format: Added documentation about compound format specifier.)
    )
    $(RUNTIMEBUGSFIXED
    )
    $(LIBBUGSFIXED
        $(LI $(BUGZILLA 4604): A stack overflow with writeln)
        $(LI $(BUGZILLA 5523): std.regex handles "\s" and "\W" (etc.) inside square brackets improperly)
        $(LI $(BUGZILLA 5652): Add \p and \P unicode properties to std.regex)
        $(LI $(BUGZILLA 5674): AssertError in std.regex)
        $(LI $(BUGZILLA 5964): std.stdio.readln can throw a UnicodeException)
        $(LI $(BUGZILLA 6217): [GSOC] result of std.algorithm.map is not movable)
        $(LI $(BUGZILLA 6403): Upgrade std.regex to Unicode UTS #18 Level 1 support)
        $(LI $(BUGZILLA 6892): Formatted write with specified length of enum member)
        $(LI $(BUGZILLA 7111): New regex engine cannot match beginning of empty string)
        $(LI $(BUGZILLA 7138): Can't call array() on dirEntries)
        $(LI $(BUGZILLA 7264): Can't iterate result from 4-arg dirEntries as string)
        $(LI $(BUGZILLA 7299): std.uni missing doc comments)
        $(LI $(BUGZILLA 7300): std.regex.ShiftOr!dchar.search is broken)
        $(LI $(BUGZILLA 7374): stdin.byLine() throws AssertError on empty input)
        $(LI $(BUGZILLA 7460): std.windows.registry reports a false exception message)
        $(LI $(BUGZILLA 7476): Write(ln) functions no longer accept retro range)
        $(LI $(BUGZILLA 7628): std.format formatValue incorrect overload)
        $(LI $(BUGZILLA 7674): regex replace requires escaped format)
        $(LI $(BUGZILLA 7679): std.regex.split and splitter don't work w/ ctRegex)
        $(LI $(BUGZILLA 7718): regex and ctRegex produce different results)
    )
    $(DMDBUGSFIXED
	$(LI rdmd: --force now works with --eval)
	$(LI rdmd: update --eval's import list)
	$(LI $(BUGZILLA 176): [module] message "module and package have the same name")
	$(LI $(BUGZILLA 783): Cannot use an array w/ const or variable index as new[] size argument.)
	$(LI $(BUGZILLA 977): Expressions inside a struct or array initializer get wrong line number)
	$(LI $(BUGZILLA 3279): Confusing error message when comparing types)
	$(LI $(BUGZILLA 3354): invalid number of args accepted for 1/2 arg floating point instructions)
	$(LI $(BUGZILLA 3509): Cannot forward reference a template mixin's members in a compile-time context)
	$(LI $(BUGZILLA 3510): Cannot forward reference a templated type from within a template mixin)
	$(LI $(BUGZILLA 3559): DMD 1.048+ fails to take function pointer from overloaded member functions)
	$(LI $(BUGZILLA 3630): bad error location in "has no effect in expression" error)
	$(LI $(BUGZILLA 3682): Regression(2.038) is expression fails to match types)
	$(LI $(BUGZILLA 3812): Missing line number for implicit cast of variadic function to array)
	$(LI $(BUGZILLA 3822): Invalid optimization of alloca called with constant size)
	$(LI $(BUGZILLA 3927): array.length++; is an error, but ++array.length compiles)
	$(LI $(BUGZILLA 4241): duplicate union initialization error doesn't give a file location)
	$(LI $(BUGZILLA 4269): Regression(2.031): invalid type accepted if evaluated while errors are gagged)
	$(LI $(BUGZILLA 4507): use spellchecker when override function doesn't override anything)
	$(LI $(BUGZILLA 4820): Regression(1.058, 2.044) in DStress caused by changeset 452)
	$(LI $(BUGZILLA 4854): Regression(2.047, Mac 10.5 only) writefln Segmentation fault if no globals)
	$(LI $(BUGZILLA 4993): Temporary values and opIndexAssign)
	$(LI $(BUGZILLA 5181): Excess cast on in-place operation op= involving conversion)
	$(LI $(BUGZILLA 5412): import wtf2)
	$(LI $(BUGZILLA 5554): [qtd] Covariance detection failure)
	$(LI $(BUGZILLA 5590): Regression(2.036) ICE(e2ir.c): when using .values on enum which is associative array)
	$(LI $(BUGZILLA 5733): Calling opDispatch As Template Results in Compiler Infinite Loop)
	$(LI $(BUGZILLA 5879): Not all frontend errors use stderr)
	$(LI $(BUGZILLA 5889): Struct literal/construction should be rvalue (it binds to ref parameters))
	$(LI $(BUGZILLA 6391): Line-less error when passing the '.im' of floating pointer value by reference)
	$(LI $(BUGZILLA 6438): [CTFE] wrong error "value used before set" when slicing =void array)
	$(LI $(BUGZILLA 6611): better error message for array post increment/decrement)
	$(LI $(BUGZILLA 6681): struct constructor call is converted to struct literal that breaks union initialization)
	$(LI $(BUGZILLA 6685): Allow using "with" with rvalues)
	$(LI $(BUGZILLA 6699): More cases of __error in error messages)
	$(LI $(BUGZILLA 6738): Can't call templatized property function from within a struct/class method)
	$(LI $(BUGZILLA 6785): Wrong error message from pragma(msg) of failed instantiation)
	$(LI $(BUGZILLA 6982): immutability isn't respected on associative array assignment)
	$(LI $(BUGZILLA 7038): Type mismatch with const struct)
	$(LI $(BUGZILLA 7110): opSlice() & opIndex functions works unstable as template arguments)
	$(LI $(BUGZILLA 7288): ICE(toir.c): with lambda return + auto)
	$(LI $(BUGZILLA 7353): NRVO not properly working with inferred return type)
	$(LI $(BUGZILLA 7380): Crash trying to use address of variable in struct constructor at module level)
	$(LI $(BUGZILLA 7399): Broken import statement in trySemantic() causes silent compiler error)
	$(LI $(BUGZILLA 7406): tuple foreach doesn't work with mixed tuples)
	$(LI $(BUGZILLA 7411): Deduce base type from vector types in templates)
	$(LI $(BUGZILLA 7439): Compound assignment causes segmentation fault)
	$(LI $(BUGZILLA 7452): Function using enforce() cannot be inferred as @safe because of anonymous function due to lazy argument)
	$(LI $(BUGZILLA 7462): Error message with _error_ in overridden function)
	$(LI $(BUGZILLA 7463): Duplicated error message with bad template value parameter)
	$(LI $(BUGZILLA 7473): [CTFE] Non-ref argument behaves as if it's a ref argument)
	$(LI $(BUGZILLA 7481): Compiler should 'soldier on' after template errors)
	$(LI $(BUGZILLA 7493): Initialization of void[][N])
	$(LI $(BUGZILLA 7499): ICE(cast.c line 1495) with lambda array)
	$(LI $(BUGZILLA 7500): [ICE] (template.c line 5287) with immutable lambda function)
	$(LI $(BUGZILLA 7502): 2.056 regression: Assigning .init takes forever to compile for large structs)
	$(LI $(BUGZILLA 7504): Cannot assign an object of type 'typeof(null)' to an array)
	$(LI $(BUGZILLA 7518): std.array.empty doesn't work for shared arrays)
	$(LI $(BUGZILLA 7525): [2.058 regression] Broken return type inference for delegate returns)
	$(LI $(BUGZILLA 7527): [CTFE] Segfault when slicing a pointer at compile time)
	$(LI $(BUGZILLA 7536): ctfeAdrOnStack triggered)
	$(LI $(BUGZILLA 7544): ICE(interpret.c) Catching an exception with a null catch block)
	$(LI $(BUGZILLA 7545): ICE(cast.c) Merge integral types through alias this)
	$(LI $(BUGZILLA 7547): -deps output lists object as a top level module)
	$(LI $(BUGZILLA 7550): Missing AVX instruction VPMULDQ)
	$(LI $(BUGZILLA 7552): Cannot get and combine a part of overloaded functions)
	$(LI $(BUGZILLA 7554): Immutable function pointer arguments too)
	$(LI $(BUGZILLA 7557): Sea of errors after template failure)
	$(LI $(BUGZILLA 7562): DMD crashes by using TemplateThisParameter)
	$(LI $(BUGZILLA 7563): Class members with default template arguments have no type)
	$(LI $(BUGZILLA 7568): pragma(msg) segfaults with an aggregate including a class.)
	$(LI $(BUGZILLA 7578): ICE on indexing result of vararg opDispatch)
	$(LI $(BUGZILLA 7580): Identity assignment of Nullable crashes dmd)
	$(LI $(BUGZILLA 7582): Untyped nested delegate literals don't compile)
	$(LI $(BUGZILLA 7583): [CTFE] ICE with tuple and alias this)
	$(LI $(BUGZILLA 7589): __traits(compiles) does not work with a template that fails to compile)
	$(LI $(BUGZILLA 7592): Conversion from ireal to ifloat broken when using xmm)
	$(LI $(BUGZILLA 7595): Data being overwritten.)
	$(LI $(BUGZILLA 7608): __traits(allMembers) is broken)
	$(LI $(BUGZILLA 7618): delegate/function pointer call bypass parameter storage class)
	$(LI $(BUGZILLA 7621): Immutable type equivalence problem)
	$(LI $(BUGZILLA 7633): Missing CTFE error message)
	$(LI $(BUGZILLA 7639): Undefined enum AA key crashes compiler)
	$(LI $(BUGZILLA 7641): std.typecons.Proxy incorrectly allows implicit conversion to class)
	$(LI $(BUGZILLA 7643): Whole tuple slice isn't resolved as expected)
	$(LI $(BUGZILLA 7649): Bad lambda inference in default function argument)
	$(LI $(BUGZILLA 7650): Bad lambda inference in associative array literal)
	$(LI $(BUGZILLA 7667): ICE(interpret.c): 'ctfeStack.stackPointer() == 0')
	$(LI $(BUGZILLA 7669): Broken inout deduction with static array type)
	$(LI $(BUGZILLA 7670): UFCS problem with @property and structs)
	$(LI $(BUGZILLA 7671): Broken inout deduction of shared(inout(T[n])) from immutable(int[3]))
	$(LI $(BUGZILLA 7672): Remove top const doesn't work for inout array type.)
	$(LI $(BUGZILLA 7681): Regression(2.059head):ICE:opCatAssign(delegate) to undefined identifier)
	$(LI $(BUGZILLA 7682): shared array type and "cast() is not an lvalue" error)
	$(LI $(BUGZILLA 7684): IFTI and shared overload doesn't work)
	$(LI $(BUGZILLA 7694): Internal error: e2ir.c 1251 when calling member function inside struct via alias param)
	$(LI $(BUGZILLA 7695): Regression(2.058): ICE(mtype.c) on associative array with keys of struct type with const members)
	$(LI $(BUGZILLA 7698): can't specialize parameterized template value)
	$(LI $(BUGZILLA 7699): Cannot get frame pointer to in contract when compiling with -inline)
	$(LI $(BUGZILLA 7702): opDispatch goes into infinite loop)
	$(LI $(BUGZILLA 7703): [UFCS] explicit template function instantiation as property)
	$(LI $(BUGZILLA 7705): lambda syntax doesn't allow some valid signatures)
	$(LI $(BUGZILLA 7713): lambda inference doesn't work on template function argument)
	$(LI $(BUGZILLA 7722): Refuse normal functions to be used as properties)
	$(LI $(BUGZILLA 7731): Assertion failure: 't' on line 7911 in file 'mtype.c')
	$(LI $(BUGZILLA 7732): [CTFE] wrong code for a struct called AssociativeArray)
	$(LI $(BUGZILLA 7735): Functions with variadic void[][]... arguments corrupt passed data)
	$(LI $(BUGZILLA 7742): 'More initializers than fields' error with correct number of fields)
	$(LI $(BUGZILLA 7743): Parsing problem with nothrow delegate)
	$(LI $(BUGZILLA 7745): Regression (1.x git-415e48a) Methods defined in external object files when a pointer to it is taken)
	$(LI $(BUGZILLA 7751): [ICE] (Regression 2.059head) From auto and forward reference)
	$(LI $(BUGZILLA 7754): static this() in template is stripped during header gen)
	$(LI $(BUGZILLA 7755): regression(2.059head): ICE in glue.c)
	$(LI $(BUGZILLA 7757): Inout function with lazy inout parameter doesn't compile)
	$(LI $(BUGZILLA 7761): lambda expression doesn't parse attributes)
	$(LI $(BUGZILLA 7768): More readable template error messages)
	$(LI $(BUGZILLA 7769): relax inout rule doesn't work for template function)
	$(LI $(BUGZILLA 7722): Refuse normal functions to be used as properties)
	$(LI $(BUGZILLA 7773): UCFS syntax on built-in attributes too?)
	$(LI $(BUGZILLA 7781): [CTFE] Segmentation fault on 'mixin({return;}());)
	$(LI $(BUGZILLA 7782): [ICE] With wrong import syntax)
	$(LI $(BUGZILLA 7785): [CTFE] ICE when slicing pointer to variable)
	$(LI $(BUGZILLA 7786): dmd crashes with invalid module name)
	$(LI $(BUGZILLA 7789): [CTFE] null pointer exception on setting array length)
	$(LI $(BUGZILLA 7794): Sea of errors when calling regex() after compile error)
	$(LI $(BUGZILLA 7808): Nullable's alias this does not work with structs containing classes)
	$(LI $(BUGZILLA 7812): Segfault on invalid code during template match deduction with errors gagged)
	$(LI $(BUGZILLA 7814): Regression(2.059head) ICE(tocsym.c) using scope(failure) within foreach-range)
	$(LI $(BUGZILLA 7815): Mixin template forward reference (?) regression)
	$(LI $(BUGZILLA 7820): regression(DMD 2.059head) Wrong error on forward reference to 'front' with -property switch)
	$(LI $(BUGZILLA 7823): Can't use a struct initializer to initialize a nested enum used as a default function argument initializer)
	$(LI $(BUGZILLA 7826): [D2 Beta] Cannot use getHash in toHash without a warning)
	$(LI $(BUGZILLA 7843): Regression(2.059 beta): Informational warning fails to produce executable)
	$(LI $(BUGZILLA 7857): File#write formats enum as a boolean.)
	$(LI $(BUGZILLA 7858): __traits(getOverloads) returns incorrect symbol)
	$(LI $(BUGZILLA 7859): Crash on invalid alias template parameter type)
	$(LI $(BUGZILLA 7861): Segfault during __error propagation with self-referencing module)
	$(LI $(BUGZILLA 7862): Accepts-invalid template forward reference bug related to derivedMembers)
	$(LI $(BUGZILLA 7868): derivedMembers/static if regression)
	$(LI $(BUGZILLA 7869): Cannot format pointer of struct has toString member function)
	$(LI $(BUGZILLA 7871): RangeViolation with findSplitBefore)
	$(LI $(BUGZILLA 7873): [2.059 beta] IFTI with inout does not properly match template parameter if called from inout function for pointers)
	$(LI $(BUGZILLA 7886): derivedMembers infinite recursion)
	$(LI $(BUGZILLA 7888): derivedMembers forward reference error with nested imports)
    )
)

$(VERSION 058, Feb 14, 2012, =================================================,

    $(WHATSNEW
	$(LI Add new => lambda syntax.)
	$(LI Allow 1.userproperty syntax.  NOTE: 1.f is no longer a float literal, add a 0.)
	$(LI Convert to -shared dmd switch instead of -dylib)
	$(LI Better use of XMM registers in OS X 32 bit target.)
	$(LI Add inline assembler support for AVX instructions (64 bit targets only).)
	$(LI Use of base class protection is now deprecated.)
	$(LI Added traits isVirtualMethod and getVirtualMethods.)
	$(LI Struct/class invariants are now implicitly const.)

      $(LI Major overhaul of std.regex module's implementation.
        $(RED Breaking change) in std.regex.replace with delegate,
        use Captures!string instead of RegexMatch!string as delegate parameter.)
      $(LI As typedef has been deprecated, overloads of std.conv.to which use
           typedef have now been deprecated.)
      $(LI std.array.insert has been deprecated. Please use std.array.insertInPlace instead.)
      $(LI The overload of std.array.replace which replaces in place has been deprecated.
           Please use std.array.replaceInPlace instead.)
      $(LI The toISOExtendedString and fromISOExtendedString functions on SysTime, Date,
           TimeOfDay, and DateTime in std.datetime have been deprecated. Please use
           toISOExtString and fromISOExtString instead.)
      $(LI std.file.getTimesPosix has been deprecated. Please use std.file.getTimes instead.)
      $(LI The overloads for isDir, isFile, and isSymlink in std.file which take a uint
           have been deprecated. Please use attrIsDir, attrIsFile, and attrIsSymlink instead.)
    )
    $(RUNTIMEBUGSFIXED
    )
    $(LIBBUGSFIXED
	$(LI $(BUGZILLA 4295): IID_IUnknown symbol undefined in phobos.lib)
	$(LI $(BUGZILLA 7241): std.format can't read into array of dchar )
    )
    $(DMDBUGSFIXED
	$(LI $(BUGZILLA 516): Mutually calling constructors allowed)
	$(LI $(BUGZILLA 620): Can't use property syntax with a template function)
	$(LI $(BUGZILLA 664): is(func T == function) ignores variadic arguments)
	$(LI $(BUGZILLA 678): Compiler accepts, for a function T[] t(), t().ptr but not t.ptr)
	$(LI $(BUGZILLA 796): Asserting a null object reference throws AssertError Failure internal\invariant.d(14) or Access Violation)
	$(LI $(BUGZILLA 949): Wrong spec/compiler behaviour for Strings, Integers and Floats)
	$(LI $(BUGZILLA 955): Passing arguments into functions - in, out, inout, const, and contracts)
	$(LI $(BUGZILLA 1313): out/body disables escape analysis)
	$(LI $(BUGZILLA 1521): Ambiguous documentation)
	$(LI $(BUGZILLA 1563): dynamic cast is not always performed)
	$(LI $(BUGZILLA 1570): Wrong return for address operator)
	$(LI $(BUGZILLA 1918): __traits(getVirtualFunctions) returns final functions)
	$(LI $(BUGZILLA 1920): Class documentation incomplete)
	$(LI $(BUGZILLA 1943): Templates can't take function pointer parameters)
	$(LI $(BUGZILLA 2106): export class doesn't affect, what is exported)
	$(LI $(BUGZILLA 2351): enum with no members allowed)
	$(LI $(BUGZILLA 2382): spec is not clear on what is allowed as global/static initializers)
	$(LI $(BUGZILLA 2387): Static array terminology)
	$(LI $(BUGZILLA 2411): Reference Tuple Foreach)
	$(LI $(BUGZILLA 2417): [module] protected base member is not available via base handle in a derived class if it is defined in a separate module)
	$(LI $(BUGZILLA 2442): opApply does not allow inferring parameter types when overloaded on const)
	$(LI $(BUGZILLA 2443): opApply should allow delegates that are not ref if it makes no sense)
	$(LI $(BUGZILLA 2483): DMD allows assignment to a scope variable)
	$(LI $(BUGZILLA 2494): describe explicit casting of arrays)
	$(LI $(BUGZILLA 2495): const syntax for member functions needs better description)
	$(LI $(BUGZILLA 2497): delete and null relationship needs more details)
	$(LI $(BUGZILLA 2524): final override inconsistent when implementing interfaces)
	$(LI $(BUGZILLA 2639): Hex and octal string values not completely specified)
	$(LI $(BUGZILLA 2819): array.sort segfaults if array length >=0x8F_FFFF)
	$(LI $(BUGZILLA 2894): abstract classes sometimes allow non-abstract bodyless functions)
	$(LI $(BUGZILLA 2997): allMembers does not return interface members)
	$(LI $(BUGZILLA 3084): Formatting of lazy in parameters section)
	$(LI $(BUGZILLA 3092): Indexing a tuple produces a tuple containing the indexed element)
	$(LI $(BUGZILLA 3111): 'mangleof' can't be member of a struct not documented)
	$(LI $(BUGZILLA 3187): Nested foreach over opApply doesn't work)
	$(LI $(BUGZILLA 3204): Document global properties)
	$(LI $(BUGZILLA 3235): [tdpl] Function literals must be deduced as "function" or "delegate")
	$(LI $(BUGZILLA 3265): .classinfo for Interface-typed reference does not return instance's ClassInfo)
	$(LI $(BUGZILLA 3492): Can't overload nested functions)
	$(LI $(BUGZILLA 3578): Impossible to run a struct invariant using assert(s))
	$(LI $(BUGZILLA 3735): op=)
	$(LI $(BUGZILLA 3757): Overloading const function with overridden non-const function results in seg fault.)
	$(LI $(BUGZILLA 3777): size_t is undefined)
	$(LI $(BUGZILLA 3783): Text inconsistent with EscapeSequence rules)
	$(LI $(BUGZILLA 3787): clarification: assigment to 'this')
	$(LI $(BUGZILLA 3791): Reference anonymous nested classes when describing new expressions)
	$(LI $(BUGZILLA 3800): "Foreach over Structs and Classes with Ranges" and "Invariant Struct" in D2 Spec)
	$(LI $(BUGZILLA 3838): PrimaryExpression rule doesn't permit module scope template instances)
	$(LI $(BUGZILLA 3886): Bad example of definition file for DLLs)
	$(LI $(BUGZILLA 3906): Undefined struct and union declarations are not documented)
	$(LI $(BUGZILLA 3908): @ attributes not part of function grammar)
	$(LI $(BUGZILLA 3954): DeclDef rule is missing TemplateMixinDeclaration)
	$(LI $(BUGZILLA 3988): Provide canonical example for operator overloading)
	$(LI $(BUGZILLA 4088): opEquals not called on interfaces)
	$(LI $(BUGZILLA 4180): D DWARF extensions conflict with DWARF-4)
	$(LI $(BUGZILLA 4251): Hole in the const system: immutable(T)[] implicitly casts to ref const(T)[])
	$(LI $(BUGZILLA 4371): segfault(template.c) template tuple in is() expression)
	$(LI $(BUGZILLA 4413): typeof(this) doesn't work in method template signature)
	$(LI $(BUGZILLA 4421): Union propagates copy constructors and destructors over all members)
	$(LI $(BUGZILLA 4523): [tdpl] .remove method for Associative Arrays returns void in all cases)
	$(LI $(BUGZILLA 4539): Refuse assignment to string literal)
	$(LI $(BUGZILLA 4545): Alias to members possible without "this" instance)
	$(LI $(BUGZILLA 4550): D2 Language Docs: http://www.digitalmars.com/d/2.0/statement.html)
	$(LI $(BUGZILLA 4553): D2 Language Docs: http://www.digitalmars.com/d/2.0/struct.html)
	$(LI $(BUGZILLA 4647): [tdpl] Cannot explicitly call final interface method, ambiguous calls allowed)
	$(LI $(BUGZILLA 4651): Docs: Returned classes that have access to stack variables of its enclosing function)
	$(LI $(BUGZILLA 4675): [tdpl] Eponymous Template should hide internal names)
	$(LI $(BUGZILLA 4711): Incorrect handling of && operator with void operand)
	$(LI $(BUGZILLA 4841): -inline wrecks nested struct with alias template parameter (An array()/map inlining problem))
	$(LI $(BUGZILLA 4887): Right-shifting by 32 is allowed and broken)
	$(LI $(BUGZILLA 4940): ICE(symbol.c): Accessing tuple-typed field of struct literal with user-defined constructor)
	$(LI $(BUGZILLA 4956): remove direct references to gcc from linux.mak)
	$(LI $(BUGZILLA 5023): Docs about order of execution of invariant and pre/post conditions)
	$(LI $(BUGZILLA 5111): Static function-level variables are not in the language spec.)
	$(LI $(BUGZILLA 5114): Too many error messages)
	$(LI $(BUGZILLA 5132): ~ unary operator silently different from C)
	$(LI $(BUGZILLA 5138): Special token sequence)
	$(LI $(BUGZILLA 5261): Uncompilable example for Windows)
	$(LI $(BUGZILLA 5299): Protected inheritance is semantically undefined.)
	$(LI $(BUGZILLA 5337): Documentation regarding interfacing with C does not account for TLS differences)
	$(LI $(BUGZILLA 5476): spec: attributes have an optional else clause)
	$(LI $(BUGZILLA 5493): Able to overwrite immutable data by passing through ref function parameter)
	$(LI $(BUGZILLA 5527): Bug in http://www.digitalmars.com/d/2.0/ctod.html#closures)
	$(LI $(BUGZILLA 5605): [tdpl] foreach with ranges doesn't support opSlice())
	$(LI $(BUGZILLA 5648): dmd command line option list inconsistencies)
	$(LI $(BUGZILLA 5713): Broken final switch on ints)
	$(LI $(BUGZILLA 5715): Contradiction in spec: meaning of variable.init)
	$(LI $(BUGZILLA 5718): Can't demangle symbol defined inside unittest block)
	$(LI $(BUGZILLA 5796): ICE with pragma(msg, ...) after missing ';' in a template)
	$(LI $(BUGZILLA 5820): Documentation states string literals can implicitly convert to char*)
	$(LI $(BUGZILLA 5841): alias grammar is incorrect)
	$(LI $(BUGZILLA 6013): private ignored for aliases)
	$(LI $(BUGZILLA 6037): [CTFE] recursive ref parameters evaluated incorrectly)
	$(LI $(BUGZILLA 6091): [d-p-l.org] Description for "Modifier casting" is misleading)
	$(LI $(BUGZILLA 6165): Anonymous enums specification)
	$(LI $(BUGZILLA 6177): Regression(2.053): ICE backend/cgcs.c: struct with destructor in assoc. array or typesafe variadic functions)
	$(LI $(BUGZILLA 6205): Strongly-pure nothrow functions with ignored return value are entirely stripped even if it contains a failing 'assert'.)
	$(LI $(BUGZILLA 6208): Parameter storage classes are ignored in template function deducing.)
	$(LI $(BUGZILLA 6364): Static struct's destructor called on exit of function)
	$(LI $(BUGZILLA 6402): Note on @property in spec needs updating)
	$(LI $(BUGZILLA 6451): [64bit] ICE(expression.c:4434): SymbolExp::SymbolExp(Loc, TOK, int, Declaration*, int): Assertion 'var' failed)
	$(LI $(BUGZILLA 6473): Stack overflow with struct destructor as default parameter)
	$(LI $(BUGZILLA 6504): Regression(2.041): "str" ~ [arr] allows string literal to be modified)
	$(LI $(BUGZILLA 6701): template specialization resolution failure)
	$(LI $(BUGZILLA 6704): CommaExpression as an IfCondition)
	$(LI $(BUGZILLA 6714): [tdpl] Type inference for parameters of function and delegate literals)
	$(LI $(BUGZILLA 6780): Templated global property functions do not work)
	$(LI $(BUGZILLA 6839): documentation for opAssign incorrect)
	$(LI $(BUGZILLA 6933): Segfault(declaration.c) using struct with destructor in CTFE)
	$(LI $(BUGZILLA 6934): [CTFE] can't use $ in a slice of an array passed by ref)
	$(LI $(BUGZILLA 6939): wrong type qualifier combination)
	$(LI $(BUGZILLA 6940): immutable(int*)*/immutable(int)** and int** do not combine)
	$(LI $(BUGZILLA 6948): Possible bug in compiler or documentation regarding signature of opCmp())
	$(LI $(BUGZILLA 6964): Error message with __error: static assert(undefined+1))
	$(LI $(BUGZILLA 6968): Segmantation fault, if exclamation mark absent)
	$(LI $(BUGZILLA 6971): [lex.dd] Type of string literals are outdated)
	$(LI $(BUGZILLA 6984): CTFE generates a torrent of spurious errors, if there was a previous error)
	$(LI $(BUGZILLA 6985): [CTFE] Non-constant case expressions can't be interpreted)
	$(LI $(BUGZILLA 6987): The "Memory Management" documentation incorrectly claims arrays are passed by reference)
	$(LI $(BUGZILLA 6995): [CTFE] can't interpret static template method)
	$(LI $(BUGZILLA 7011): No line number error for vector power)
	$(LI $(BUGZILLA 7037): TemplateTypeParameterSpecialization works differently from IsExpression regarding alias this)
	$(LI $(BUGZILLA 7043): CTFE: ICE illegal reference value 0LU, only with -inline)
	$(LI $(BUGZILLA 7073): Parsing of class-returning varargs function inside module ctor fails)
	$(LI $(BUGZILLA 7108): ICE: TraitsExp::semantic(Scope*) 2.056 -> 2.057 regression - segfault)
	$(LI $(BUGZILLA 7120): Scope Delegates + Delegate Literals)
	$(LI $(BUGZILLA 7123): static assert(is(typeof(toDelegate(&main)))) is false)
	$(LI $(BUGZILLA 7124): Alias this type is not considered in template type deduction)
	$(LI $(BUGZILLA 7127): Const-related infinite recursion in DWARF generation)
	$(LI $(BUGZILLA 7133): [tdpl] There should be no empty statement)
	$(LI $(BUGZILLA 7136): alias this lookup should run before merging modifiers of both sides.)
	$(LI $(BUGZILLA 7143): [CTFE] cannot compare class references with "is")
	$(LI $(BUGZILLA 7144): [CTFE] base class does not call overridden members)
	$(LI $(BUGZILLA 7154): [CTFE] failing downcast causes error)
	$(LI $(BUGZILLA 7158): [CTFE] ICE(interpret.c) calling a class member using a dotvar expression)
	$(LI $(BUGZILLA 7160): Regression(2.057): ICE(dsymbol.c:1052) ICE using __traits(derivedMembers))
	$(LI $(BUGZILLA 7162): [CTFE] "bool || void" expression crashes dmd)
	$(LI $(BUGZILLA 7165): [CTFE] ice converting null pointer to bool with constant member function)
	$(LI $(BUGZILLA 7166): Internal error: ../ztc/cgxmm.c 60)
	$(LI $(BUGZILLA 7168): Regression(2.057) __traits(allMembers) returns wrong tuple)
	$(LI $(BUGZILLA 7170): [UFCS] array + specialized template member syntax causes ICE)
	$(LI $(BUGZILLA 7173): dmd: glue.c:1065: virtual unsigned int Type::totym(): Assertion `0` failed.)
	$(LI $(BUGZILLA 7178): Segfault with import of invalid template)
	$(LI $(BUGZILLA 7185): [CTFE] ICE on changing char array length)
	$(LI $(BUGZILLA 7187): Regression(head 12d62ca5): [CTFE] ICE on slicing)
	$(LI $(BUGZILLA 7188): "import phobos;" crashes DMD)
	$(LI $(BUGZILLA 7189): inline failed)
	$(LI $(BUGZILLA 7190): Tuple length incorrect)
	$(LI $(BUGZILLA 7193): Regression(2.058head): ICE: delete lambda expression crashes dmd)
	$(LI $(BUGZILLA 7194): [CTFE] Incorrect behaviour with pointers as local struct variable)
	$(LI $(BUGZILLA 7196): Unfair function address overload resolution)
	$(LI $(BUGZILLA 7197): enum string doesn't work with CTFE)
	$(LI $(BUGZILLA 7199): std.string.indexof cannot be compiled with -inline)
	$(LI $(BUGZILLA 7201): Lambda template assignment to variable)
	$(LI $(BUGZILLA 7207): Explicit cast should resolve lambda type)
	$(LI $(BUGZILLA 7212): Regression(Head): ICE with overload resolution and delegate/function inference)
	$(LI $(BUGZILLA 7216): [CTFE] Can't call struct member function using pointer field)
	$(LI $(BUGZILLA 7217): [CTFE] ICE on accessing struct array field)
	$(LI $(BUGZILLA 7218): Nested function with contract is rejected)
	$(LI $(BUGZILLA 7228): MOVDQ2Q instruction is emitted with swapped register indices)
	$(LI $(BUGZILLA 7231): Segfault using opDispatch with property notation)
	$(LI $(BUGZILLA 7232): Warning: statement is not reachable has no line number)
	$(LI $(BUGZILLA 7234): Segmentation fault when using stdio)
	$(LI $(BUGZILLA 7239): C style struct initialization doesn't work with aliases)
	$(LI $(BUGZILLA 7245): [CTFE] Address of ref foreach parameter changes to point after array)
	$(LI $(BUGZILLA 7248): [CTFE] Stack overflow on using struct filed pointer with address of array element)
	$(LI $(BUGZILLA 7261): ICE(glue.c): With taskPool.reduce)
	$(LI $(BUGZILLA 7266): [CTFE] Assign to ref param (that's taken from struct member) is noop)
	$(LI $(BUGZILLA 7277): [CTFE ICE] Assertion failure: 'thisval' on line 1690 in file 'interpret.c')
	$(LI $(BUGZILLA 7278): Templated struct (instantiated with null) can't access its own members)
	$(LI $(BUGZILLA 7285): Implicit fixed-size array cast)
	$(LI $(BUGZILLA 7290): Heap allocation with scoped delegate literal)
	$(LI $(BUGZILLA 7294): [Regression] No warning when escaping local reference type variables)
	$(LI $(BUGZILLA 7295): Alias This + Pure + pointsTo = rejects-valid)
	$(LI $(BUGZILLA 7296): [2.058] Regression: Cannot swap RefCounted)
	$(LI $(BUGZILLA 7309): [2.058] Regression caused by new inlining code)
	$(LI $(BUGZILLA 7321): returning void considered unsafe by safety inference)
	$(LI $(BUGZILLA 7335): sometimes the OUT - block have undefined class members-acces)
	$(LI $(BUGZILLA 7351): Possible asm bug: bad type/size of operands 'xadd')
	$(LI $(BUGZILLA 7359): Template function with typesafe variadic rejects more than one string arguments)
	$(LI $(BUGZILLA 7363): Eponymous Template doesn't hide internal names in some cases with `static if`)
	$(LI $(BUGZILLA 7365): [Regression after 2.057] AAs broken for Object keys and values with opEquals)
	$(LI $(BUGZILLA 7367): wrong char comparison result)
	$(LI $(BUGZILLA 7369): Inout constructor causes compiler to reject invariant)
	$(LI $(BUGZILLA 7373): (Regression git) Renamed imports conflict with other implicitly imported symbols)
	$(LI $(BUGZILLA 7375): Regression(2.057): Invalid downcast permitted with derived/aliased template classes)
	$(LI $(BUGZILLA 7377): Compiler segfault in: TemplateMixin::hasPointers())
	$(LI $(BUGZILLA 7379): DMD segfaults on semantic3 phase when alias enum this)
	$(LI $(BUGZILLA 7383): Blank lines in code sections cause premature section termination)
	$(LI $(BUGZILLA 7384): Typo in volatile deprecation message)
	$(LI $(BUGZILLA 7394): ddmangle tool needs rebuilding)
	$(LI $(BUGZILLA 7416): 2.058 regression: fails to instantiate a constrained function template with a nested function)
	$(LI $(BUGZILLA 7419): [2.058/CTFE] Constructor of struct is overwritten inside a unittest with -inline)
	$(LI $(BUGZILLA 7422): Regression(master): ICE with template function and if statement)
	$(LI $(BUGZILLA 7424): Segfault when trying to call a templated property with different const-ancy.)
	$(LI $(BUGZILLA 7425): IFTI does not work with inout methods)
	$(LI $(BUGZILLA 7428): regression (DMD 2.058head) ICE on slightly convoluted setup including closures)
	$(LI $(BUGZILLA 7435): Regression(master):dmd crashes when 'scope(failure) debug ...' without -debug option.)
	$(LI $(BUGZILLA 7475): Regression(2.058 beta): Template member erroneously inaccessible)
	$(LI $(BUGZILLA 7498): function expected before (), not function)
    )
)

$(VERSION 057, Dec 13, 2011, =================================================,

    $(WHATSNEW
	$(LI Better use of XMM registers in 64 bit targets.)
	$(LI The $(D_KEYWORD invariant) keyword as a synonym for $(D_KEYWORD immutable) is now deprecated - use $(D_KEYWORD immutable) instead)
	$(LI Add Mach-O 64 bit support for obj2asm and dumpobj)
	$(LI classes, interfaces, and exceptions are supported in CTFE)
	$(LI $(BUGZILLA 3474): PATCH: Implement opDollar for struct and class indexing operations)
	$(LI $(BUGZILLA 6572): Deprecate typedef)

        $(LI Major overhaul of std.regex module's implementation.
           $(RED Breaking change) in std.regex.replace with delegate,
           use Captures!string instead of RegexMatch!string as delegate parameter.)
        $(LI As typedef has been deprecated, overloads of std.conv.to which use
           typedef have now been deprecated.)
        $(LI std.array.insert has been deprecated. Please use std.array.insertInPlace instead.)
        $(LI The overload of std.array.replace which replaces in place has been deprecated.
           Please use std.array.replaceInPlace instead.)
        $(LI The toISOExtendedString and fromISOExtendedString functions on SysTime, Date,
           TimeOfDay, and DateTime in std.datetime have been deprecated. Please use
           toISOExtString and fromISOExtString instead.)
        $(LI std.file.getTimesPosix has been deprecated. Please use std.file.getTimes instead.)
        $(LI The overloads for isDir, isFile, and isSymlink in std.file which take a uint
           have been deprecated. Please use attrIsDir, attrIsFile, and attrIsSymlink instead.)
	$(LI $(BUGZILLA 2550): implicit conversions don't apply to template value parameter specialization)
	$(LI $(BUGZILLA 3467): Non-int integral template parameters not correctly propagated)
	$(LI Removed top const from dynamic array types and pointer types in IFTI.)
    )
    $(RUNTIMEBUGSFIXED
	$(LI $(BUGZILLA 6909): incorrect definition of the OVERLAPPED struct in core.sys.windows.windows ?)
    )
    $(LIBBUGSFIXED
        $(LI Unlisted bug: std.conv: Fix to!float("-0"))
        $(LI Unlisted bug: std.file broken on OS X x86_64 due to wrong stat64 declaration.)
        $(LI $(BUGZILLA 2936): std.regex.match() short string optimization)
        $(LI $(BUGZILLA 4765): std.math.modf always returns 0)
        $(LI $(BUGZILLA 5193): SList cannot have struct elements that have immutable members.)
        $(LI $(BUGZILLA 5620): Implicit conversion of RegexMatch to bool.)
        $(LI $(BUGZILLA 5712): [patch] std.regex.replace disallows w/dstring)
        $(LI $(BUGZILLA 6204): emplace() for classes accepts larger chunk but fails in array assignment)
        $(LI $(BUGZILLA 6887): Regression of getopt)
        $(LI $(BUGZILLA 6888): std.getopt.getopt: one-letter hash option causes range violation)
        $(LI $(BUGZILLA 6935): struct with @disable this cannot make range)
	$(LI $(BUGZILLA 6953): std.concurrency needs more documentation)
        $(LI $(BUGZILLA 6973): static assert(isOutputRange!(OutputRange!int, int)) is false)
        $(LI $(BUGZILLA 6976): GetLastError called as property)
        $(LI $(BUGZILLA 6977): getErrno called as property in std.stdio)
        $(LI $(BUGZILLA 6979): hasUnsharedAliasing cannot accept plural parameters)
        $(LI $(BUGZILLA 6990): std.string.splitlines deprecation doc missing a word)
        $(LI $(BUGZILLA 7000): missing import of std.stdio in std.regex?)
        $(LI $(BUGZILLA 7039): Posix 2.057 Makefile error breaking 64bit build)
        $(LI $(BUGZILLA 7040): Phobos must use "version/else version" blocks for proper
                               documentation generation.)
        $(LI $(BUGZILLA 7045): AssertError in std.regex on line 1573)
        $(LI $(BUGZILLA 7055): to!float("INF2") == 2)
    )
    $(DMDBUGSFIXED
	$(LI $(BUGZILLA 2095): covariance w/o typechecks = bugs)
	$(LI $(BUGZILLA 2532): '=' does not give a boolean result)
	$(LI $(BUGZILLA 2778): alias this + IFTI doesn't work.)
	$(LI $(BUGZILLA 2856): static opIndex does not compile for a templated struct/class)
	$(LI $(BUGZILLA 3990): Deferencing a dynamic array as pointer)
	$(LI $(BUGZILLA 4047): [CTFE] class/struct heap allocation)
	$(LI $(BUGZILLA 4401): auto functions cannot be inner functions)
	$(LI $(BUGZILLA 4511): Contravariance problem)
	$(LI $(BUGZILLA 4583): PIC code not working: EBX register set incorrectly)
	$(LI $(BUGZILLA 5311): Pure is broken when accessing globals / static data through instance reference)
	$(LI $(BUGZILLA 5364): optimizer kills high dword of -1)
	$(LI $(BUGZILLA 5416): null should have a type of its own)
	$(LI $(BUGZILLA 5899): auto-return function cannot match 'null' with reference type.)
	$(LI $(BUGZILLA 6056): Type lookup problem in string mixins)
	$(LI $(BUGZILLA 6077): CTFE: Cannot append null array to null array.)
	$(LI $(BUGZILLA 6330): Cannot disable assignment to a struct.)
	$(LI $(BUGZILLA 6354): Optimizer bug on x86_64: Bitshift optimized out when foreach and scope(failure) are used)
	$(LI $(BUGZILLA 6416): [CTFE] Declaration static struct is not yet implemented in CTFE)
	$(LI $(BUGZILLA 6479): spurious alias this with struct and mixin template)
	$(LI $(BUGZILLA 6522): [CTFE] Problem with opAssign call in foreach(ref))
	$(LI $(BUGZILLA 6603): [CTFE] Can't call through a manifest constant function pointer)
	$(LI $(BUGZILLA 6736): Regression(2.054): ICE (cgcod.c 1672) with alias this and certain structs)
	$(LI $(BUGZILLA 6763): Using TypeTuple with (const/in/ref etc.) changes it forever)
	$(LI $(BUGZILLA 6792): [CTFE] ICE with pointer cast of indexed array)
	$(LI $(BUGZILLA 6800): [CTFE] dangerous pointer casts should be rejected)
	$(LI $(BUGZILLA 6805): Can't use a type from opDispatch template)
	$(LI $(BUGZILLA 6816): [CTFE] nested function can't access this)
	$(LI $(BUGZILLA 6817): [CTFE] Error on interpreting inlined IfStatement)
	$(LI $(BUGZILLA 6832): Can't test objects wrapped with alias this)
	$(LI $(BUGZILLA 6836): map + UFCS = fail)
	$(LI $(BUGZILLA 6837): alias this + UFCS = fail)
	$(LI $(BUGZILLA 6851): [CTFE] Cannot deref pointer passed by argument)
	$(LI $(BUGZILLA 6859): Segfault when abstract method uses with contract.)
	$(LI $(BUGZILLA 6864): Const conversion should precedence over the shared one)
	$(LI $(BUGZILLA 6865): inout matching removes shared qualifier)
	$(LI $(BUGZILLA 6866): ICE(mtype.c): alias this and inout matching)
	$(LI $(BUGZILLA 6867): inout and nested foreach loops)
	$(LI $(BUGZILLA 6868): IsExp + incorrect static array type = error)
	$(LI $(BUGZILLA 6870): type qualifiers behave inconsistently in combination with typeof)
	$(LI $(BUGZILLA 6872): Breaking type parsing of shared(inout(int)[]))
	$(LI $(BUGZILLA 6877): [XMM] regression, clobbered float value)
	$(LI $(BUGZILLA 6879): The difference of between template matching and IsExp)
	$(LI $(BUGZILLA 6881): [XMM] ICE with painted float)
	$(LI $(BUGZILLA 6885): [CTFE] wrong code with dynamically allocated 2D array)
	$(LI $(BUGZILLA 6886): [CTFE] ICE(interpret.c) new array with initializer)
	$(LI $(BUGZILLA 6901): wrong error "override cannot be applied to variable" in CTFE forward reference)
	$(LI $(BUGZILLA 6902): Different "pure nothrow int()" types)
	$(LI $(BUGZILLA 6910): __traits(hasMember, "$(LESS)name$(GREATER)") does not work, if template has alias param)
	$(LI $(BUGZILLA 6912): const(T)[] can be implicitly cast to inout(const(T)[]))
	$(LI $(BUGZILLA 6919): [CTFE] Cannot get effect to local variable through its pointer)
	$(LI $(BUGZILLA 6922): [TDPL] superimposing of const and immutable does not work correctly)
	$(LI $(BUGZILLA 6927): Better @property management by chained functions)
	$(LI $(BUGZILLA 6928): alias this, immutable and common type fail in presence of fields with indirections)
	$(LI $(BUGZILLA 6929): [ICE] typeMerge crashes in presence of ambiguous alias this conversions)
	$(LI $(BUGZILLA 6941): .stringof displays redundant storage classes)
	$(LI $(BUGZILLA 6972): [CTFE] ICE with ubyte/=uint)
	$(LI $(BUGZILLA 6994): Using explicit 'this' in template constraint causes an error)
	$(LI $(BUGZILLA 6997): 64bit optimizer bug)
	$(LI $(BUGZILLA 7004): Iterating tuple with index which explicitly typed as size_t causes an error)
	$(LI $(BUGZILLA 7026): 64 bit optimizer bug)
	$(LI $(BUGZILLA 7027): Struct member trySemantic() regression in DMD Git master)
	$(LI $(BUGZILLA 7028): Fails to save FPU regs when executing finally block)
	$(LI $(BUGZILLA 7072): [2.057 Beta] Assertion failure: '0' on line 145 in file 'mtype.c')
	$(LI $(BUGZILLA 7093): aliased type sometimes isn't resolved)
    )
)

$(VERSION 056, Oct 26, 2011, =================================================,

    $(WHATSNEW
	$(LI add -gs compiler switch)
	$(LI $(BUGZILLA 3194): invariant should be checked at the beginning and end of protected functions)
	$(LI $(BUGZILLA 5399): Return the result of a nonvoid function in a void function)
	$(LI $(BUGZILLA 6752): Add separate option to control stack frame generation)
        $(LI std.exception: enforce/enforceEx now can use in @safe pure function.)
        $(LI Added optional KeepTerminator param to std.string.splitLines.)
        $(LI Added std.string.outdent.)
        $(LI std.utf: More @safe and pure.)
        $(LI std.windows.registry now use *W functions in order to deal properly with Unicode.)
    )
    $(RUNTIMEBUGSFIXED
	$(LI $(BUGZILLA 5967): Mangling of ArgClose for variadic function is swapped)
	$(LI $(BUGZILLA 6493): Source code for the doc of core.time points to std.datetime.)
	$(LI $(BUGZILLA 6466): core.demangle incorrect demangling of variables)
    )
    $(LIBBUGSFIXED
        $(LI $(BUGZILLA 5522): std.range.zip fails on arrays of Object.)
        $(LI $(BUGZILLA 6009): std/container disabled on freebsd/64)
        $(LI $(BUGZILLA 6160): std.conv.to: Ignore _ to match the rest of D)
        $(LI $(BUGZILLA 6181): assert fails in datetime.d while runining Phobos unittest)
        $(LI $(BUGZILLA 6258): std.conv.to!real("-") fetches the front of an empty array.)
        $(LI $(BUGZILLA 6275): Const values in tuples)
        $(LI $(BUGZILLA 6288): std.conv.to removes const/immutable when converting a class)
        $(LI $(BUGZILLA 6609): std.conv.parse!Integer should consider sign when radix == 10)
        $(LI $(BUGZILLA 6634): std.path.globMatch throws wrong assertion)
        $(LI $(BUGZILLA 6640): More formatting consistency between string and range of char)
        $(LI $(BUGZILLA 6761): Strange behavior of RedBlackTree causing a dangling pointer)
	$(LI $(BUGZILLA 6819): BigInt ^^ fails for some big numbers (powers))
    )
    $(DMDBUGSFIXED
	$(LI $(BUGZILLA 546): Error message for accessing a deprecated variable is doubled)
	$(LI $(BUGZILLA 1339): Invariant/const-ness is broken by built-in array properties sort and reverse)
	$(LI $(BUGZILLA 1891): Array-concatenation of T* and T*[] produces corrupted result)
	$(LI $(BUGZILLA 1993): Error calling vararg delegate with null)
	$(LI $(BUGZILLA 2315): DMD Stack Overflow on unwanted ctfe recursion)
	$(LI $(BUGZILLA 2553): Excess attribute propagation for interfaces)
	$(LI $(BUGZILLA 2361): delete is allowed on invariant references.)
	$(LI $(BUGZILLA 2737): Nonsensical Error Message on Unsafe .idup)
	$(LI $(BUGZILLA 2740): Template Mixins do not work as advertised)
	$(LI $(BUGZILLA 2953): tuple.length rejected as a tuple parameter in a static foreach)
	$(LI $(BUGZILLA 3069): Array literals do not implicitly cast to void[])
	$(LI $(BUGZILLA 3133): Compiler does not check that static array casts are legal)
	$(LI $(BUGZILLA 3180): Covariance of delegates/function pointers)
	$(LI $(BUGZILLA 3550): array.dup violates const/invariant without a cast.)
	$(LI $(BUGZILLA 3659): Too much exegesis on opEquals)
	$(LI $(BUGZILLA 3748): inout does not work properly)
	$(LI $(BUGZILLA 4022): [CTFE] AA get)
	$(LI $(BUGZILLA 4197): ICE(glue.c): error in forward-referenced in/out contract)
	$(LI $(BUGZILLA 4206): type accepted as enum initializer)
	$(LI $(BUGZILLA 4237): Typedefs of the same name cause initializer conflict)
	$(LI $(BUGZILLA 4269): Regression(2.031): invalid type accepted if evaluated while errors are gagged)
	$(LI $(BUGZILLA 4284): empty string[] alias lacks .length in a template)
	$(LI $(BUGZILLA 5453): ICE(statement.c): invalid switch statement forward referenced by CTFE)
	$(LI $(BUGZILLA 5696): Templates typetuple iteration)
	$(LI $(BUGZILLA 5703): std.intrinsic. and core.bitop.bsf, bsr and bswap should be CTFE-able)
	$(LI $(BUGZILLA 5886): Template this parameter cannot be made implicit, when other parameters are explicitly given)
	$(LI $(BUGZILLA 5932): Internal error: s2ir.c 339)
	$(LI $(BUGZILLA 6062): segv in dmd/64 with assoc array literals)
	$(LI $(BUGZILLA 6073): Cannot pass __traits(parent, ...) as a template parameter if it is a module)
	$(LI $(BUGZILLA 6084): Impossible to instantiate local template with TypeTuple-foreach iterator variable.)
	$(LI $(BUGZILLA 6087): typeof(this) doesn't work outside member function)
	$(LI $(BUGZILLA 6139): Duplicate error message on compile-time out of bounds array index)
	$(LI $(BUGZILLA 6289): Make slices of const/immutable arrays mutable (but keep the elements const/immutable))
	$(LI $(BUGZILLA 6296): ICE(glue.c): invalid template instantiated in is(typeof()).)
	$(LI $(BUGZILLA 6352): Regression(2.054) Implicit pure/nothrow/@safe messes up delegate arrays)
	$(LI $(BUGZILLA 6360): @property is doubled in di files when used with auto)
	$(LI $(BUGZILLA 6404): Cannot check ref-ness of auto ref parameter in template constraint)
	$(LI $(BUGZILLA 6488): DMD compiler bug)
	$(LI $(BUGZILLA 6518): break inside a static foreach inside a switch)
	$(LI $(BUGZILLA 6529): writeln(const array of enums) too)
	$(LI $(BUGZILLA 6584): ICE on large version number/debug level)
	$(LI $(BUGZILLA 6596): Error message with not extern(C) function)
	$(LI $(BUGZILLA 6599): Segfault: invalid expression in initializer)
	$(LI $(BUGZILLA 6630): Assigning null to class with nested alias this class is misinterpreted)
	$(LI $(BUGZILLA 6656): static alias this broken in 2.055)
	$(LI $(BUGZILLA 6661): Templates instantiated only through is(typeof()) shouldn't cause errors)
	$(LI $(BUGZILLA 6665): Regression(2.055) ICE(cg87.c): static double inside closure)
	$(LI $(BUGZILLA 6672): [CTFE] ICE on compile time std.algorithm.sort)
	$(LI $(BUGZILLA 6674): Regression(2.055) mixin and __traits(allMembers) generates incorrect result)
	$(LI $(BUGZILLA 6675): Regression(2.054) ICE(glue.c) template parameter deduction with errors gagged)
	$(LI $(BUGZILLA 6682): Template function that has lazy parameter is not inferred as pure)
	$(LI $(BUGZILLA 6690): Using lazy parameter should be inferred as @safe)
	$(LI $(BUGZILLA 6691): static constructor inside template cannot initialize immutable template members)
	$(LI $(BUGZILLA 6693): [CTFE] Cannot set value to nested AA)
	$(LI $(BUGZILLA 6695): typeof(this) does not take into account const/immutable attributes inside member functions)
	$(LI $(BUGZILLA 6698): Regression(2.053): segfault with naked asm in inner function)
	$(LI $(BUGZILLA 6700): Regression(2.053) using $ inside a slice of a tuple)
	$(LI $(BUGZILLA 6719): "Error: out of memory" in parsing)
	$(LI $(BUGZILLA 6721): [CTFE] Cannot get pointer to start of char[])
	$(LI $(BUGZILLA 6727): [CTFE] ICE(interpret.c): assignment from string literal.dup.ptr)
	$(LI $(BUGZILLA 6733): Regression(2.054) ICE(cod2.c) pure nothrow func with side-effect parameters)
	$(LI $(BUGZILLA 6739): [CTFE] Cannot set a value to an outer AA of a nested AA)
	$(LI $(BUGZILLA 6746): static this() inside struct skipped upon static method call)
	$(LI $(BUGZILLA 6749): [CTFE] problem with array of structs)
	$(LI $(BUGZILLA 6751): [CTFE] ref argument of AA doesn't work)
	$(LI $(BUGZILLA 6753): Regression(2.055beta) "Reinterpret" cast of array to a tail const one doesn't work inside @trusted)
	$(LI $(BUGZILLA 6759): missing initialization in foreach with alias this)
	$(LI $(BUGZILLA 6765): [CTFE]: AA.length doesn't compile when AA is null)
	$(LI $(BUGZILLA 6769): [CTFE] AA.keys doesn't compile when -inline is used)
	$(LI $(BUGZILLA 6770): inout is allowed on fields)
	$(LI $(BUGZILLA 6773): inout variable should not be modifiable)
	$(LI $(BUGZILLA 6775): [CTFE] foreach over an AA fails to compile)
	$(LI $(BUGZILLA 6782): inout-correct range is not iterable using foreach with type deduction inside non-inout function)
	$(LI $(BUGZILLA 6813): Yet another "cannot get frame pointer" error)
	$(LI $(BUGZILLA 6822): New ubuntu linking rules prevent dmd from linking programs on Ubuntu 11.10)
	$(LI $(BUGZILLA 6825): Regression(2.055+): Address of templated method incorrectly taken)
    )
)

$(VERSION 055, Sep 4, 2011, =================================================,

    $(WHATSNEW
	$(LI Added $(LINK2 http://www.digitalmars.com/ctg/dman.html, dman))
	$(LI Add support for Mac OS X 10.7 Lion)
	$(LI Add protection to json output)
	$(LI Add SSE4.1 and SSE4.2 assembly instructions)
	$(LI $(BUGZILLA 4375): Require explicit braces when 'else' is ambiguous)

      $(LI std.algorithm.copy now specializes on arrays for 10-80x improved
           performance.)
      $(LI std.path has been rewritten from scratch and has a completely new API.)
      $(LI std.utf.toUTFz allows you to get a zero-terminated string of any
           character type and of any type of mutability.)
      $(LI Added symlink and readLink to std.file for Posix systems.)
      $(LI Values for GDC and LDC were added to std.compiler.Vendor.)
      $(LI Added functions to std.bitswap for generically handling swapping
           endianness.)
      $(LI Added std.parallelism.TaskPool.workerIndex.)
      $(LI Added buffer recycling overload of std.parallelism.asyncBuf)
      $(LI std.math.tgamma, lgamma, erf, and erfc are now deprecated. The
           equivalent functions in std.mathspecial should be used instead.)
      $(LI The names of the values of std.mmfile.Mode, std.system.Endian,
           std.traits.FunctionAttributes, std.traits.ParameterStorageClass,
           and std.traits.Variadic were changed to match Phobos' naming conventions.)
      $(LI std.range:  Added indexed and chunks)
      $(LI std.string.translate has been updated to work with unicode. As a
           result, its signature has been changed. The old version and
           std.string.maketrans have been scheduled for deprecation.)
      $(LI std.string.tr has been updated so that it works with any string type.)
      $(LI std.conv.parse works for associative array and static array)
      $(LI std.format: Improvement of formatValue and unformatValue.
           They now works for associative array, consider element escaping,
           and treat range format spec more properly.)
	$(LI std.complex: added sin(), cos(), sqrt())
	$(LI md5: 1.4X speedup)
    )
    $(RUNTIMEBUGSFIXED
	$(LI $(BUGZILLA 5967): Mangling of ArgClose for variadic function is swapped)
	$(LI $(BUGZILLA 6493): Source code for the doc of core.time points to std.datetime.)
	$(LI $(BUGZILLA 6466): core.demangle incorrect demangling of variables)
    )
    $(LIBBUGSFIXED
        $(LI Unlisted bug:  std.range.transversal should have length)
        $(LI $(BUGZILLA 3890): Bad writeln of a nested struct)
	$(LI $(BUGZILLA 4500): scoped moves class after calling the constructor)
        $(LI $(BUGZILLA 4977): cannot use nothrow or pure with Rebindable)
        $(LI $(BUGZILLA 5237): writefln doesn't respect Complex.toString)
        $(LI $(BUGZILLA 5645): std.range.drop())
        $(LI $(BUGZILLA 5825): write is calling a deprecated function)
	$(LI $(BUGZILLA 6040): std.cpuid and core.cpuid return different values for some methods)
        $(LI $(BUGZILLA 6064): std.array.join is unnecssarily slow for strings)
        $(LI $(BUGZILLA 6194): [GSoC] Destructor gets called on object before it is copied when calling writeln())
        $(LI $(BUGZILLA 6261): [2.054 beta regression] Regex cannot take a char[])
	$(LI $(BUGZILLA 6301): Cannot 'zip'/'retro'/'stride' etc. a range having 'ulong' length.)
        $(LI $(BUGZILLA 6377): std.conv.to should check range when changing signedness)
	$(LI $(BUGZILLA 6424): std.traits.hasElaborateAssign is limited)
	$(LI $(BUGZILLA 6448): writef("%05d", BigInt) problem)
	$(LI $(BUGZILLA 6514): CTFE dot product)
        $(LI $(BUGZILLA 6587): std.parallelism's Task cannot handle immutable values)
        $(LI $(BUGZILLA 6606): RefCounted doesn't work with unions due to use of format)
        $(LI $(BUGZILLA 6608): Tuple field is not escaped)
    )
    $(DMDBUGSFIXED
	$(LI $(BUGZILLA 1471): Linker error on template function. Error 42: Symbol Undefined ...)
	$(LI $(BUGZILLA 1567): call to private super-constructor should not be allowed)
	$(LI $(BUGZILLA 1684): offsetof does not work, adding cast is workaround)
	$(LI $(BUGZILLA 1904): wrong protection lookup for private template functions)
	$(LI $(BUGZILLA 2156): [] and null should be accepted where a compile-time string is required)
	$(LI $(BUGZILLA 2234): __traits(allMembers) returns incorrect results for mixin and template alias members of an aggregate)
	$(LI $(BUGZILLA 2245): Bug with overloaded, mixin template functions in classes)
	$(LI $(BUGZILLA 2246): Regression(2.046, 1.061): Specialization of template to template containing int arguments fails)
	$(LI $(BUGZILLA 2540): super can not be using in alias statement)
	$(LI $(BUGZILLA 2634): Function literals are non-constant.)
	$(LI $(BUGZILLA 2355): is() doesn't resolve aliases before template matching)
	$(LI $(BUGZILLA 2579): Template function accepting a delegate with in argument doesn't compile)
	$(LI $(BUGZILLA 2774): Functions-as-properties makes it impossible to get the .mangleof a function)
	$(LI $(BUGZILLA 2777): alias this doesn't forward __dollar and slice op.)
	$(LI $(BUGZILLA 2781): alias this doesn't work with foreach)
	$(LI $(BUGZILLA 2787): Members found in an 'alias this' are not implicitly accessible in methods)
	$(LI $(BUGZILLA 2941): Wrong code for inline asm because CPU type is set too late)
	$(LI $(BUGZILLA 3268): can't compare pointer to functions when one is const)
	$(LI $(BUGZILLA 3273): Regression(2.031): struct invariant + dtor fails to compile (no line number))
	$(LI $(BUGZILLA 3512): dchar iteration over string in CTFE fails)
	$(LI $(BUGZILLA 3661): ^^ not supported in array operations.)
	$(LI $(BUGZILLA 3797): Regression(2.038): Implicit conversion between incompatible function pointers)
	$(LI $(BUGZILLA 4021): [CTFE] AA rehash)
	$(LI $(BUGZILLA 4099): Inconsistent behaviour of ++/-- when mixing opUnary and 'alias this'.)
	$(LI $(BUGZILLA 4444): Cannot index built-in array with expression tuple)
	$(LI $(BUGZILLA 4460): Regression(2.036) ICE(e2ir.c) when compiling foreach over associative array literal)
	$(LI $(BUGZILLA 4682): [CTFE] Run-time Vs Compile-time of int.min % -1)
	$(LI $(BUGZILLA 4773): Rebindable should be castable to bool)
	$(LI $(BUGZILLA 4837): ICE(constfold.c) CTFE with >>>=)
	$(LI $(BUGZILLA 4984): Recursive template constraint results in dmd running out of memory)
	$(LI $(BUGZILLA 5046): Wrong type of implicit 'this' in struct/class templates)
	$(LI $(BUGZILLA 5081): Pure functions as initializers for immutable structures)
	$(LI $(BUGZILLA 5188): alias this and compare expression generates wrong code)
	$(LI $(BUGZILLA 5239): optimizer misreports an used before set error)
	$(LI $(BUGZILLA 5373): Regression (2.051) CTFE and std.string.replace() causes "Bad binary function q{a == b}..)
	$(LI $(BUGZILLA 5440): ICE(template.c): when struct AssociativeArray is missing from object.d)
	$(LI $(BUGZILLA 5585): bad debug line number info for return statements with enumerator expressions)
	$(LI $(BUGZILLA 5745): Missing error line number with lazy argument)
	$(LI $(BUGZILLA 5750): Allow pure functions to have lazy arguments)
	$(LI $(BUGZILLA 5777): Move semantics require full spec NRVO)
	$(LI $(BUGZILLA 5785): Lexing or Parsing issue with UFCS)
	$(LI $(BUGZILLA 5790): 'Error: variable result used before set' when -release -inline -O)
	$(LI $(BUGZILLA 5799): Address-of operator fails on nested conditional operator expression)
	$(LI $(BUGZILLA 5936): Regression(2.050): Segfault when forward-referencing pure auto-return member function with parameter.)
	$(LI $(BUGZILLA 5953): Too many trailing commas are accepted)
	$(LI $(BUGZILLA 6097): SSSE3 not working with MMX instructions)
	$(LI $(BUGZILLA 6215): LLVM-compiled DMD segfaults due to mem.c alignment issues)
	$(LI $(BUGZILLA 6220): Regression(2.053) static foreach over a string[] no longer produces directly usable strings)
	$(LI $(BUGZILLA 6228): Regression(2.053) ICE(e2ir.c) on {auto x = (*ptr) ^^ y} with const integer types)
	$(LI $(BUGZILLA 6230): Member functions can no longer be weakly pure)
	$(LI $(BUGZILLA 6250): [CTFE] Crash when swapping two pointers to arrays.)
	$(LI $(BUGZILLA 6265): Pure-inference failed when calling other pure functions)
	$(LI $(BUGZILLA 6270): XMMREGS not preserved on indirect function call)
	$(LI $(BUGZILLA 6276): [CTFE] Strange behavior of using ~= operator twice)
	$(LI $(BUGZILLA 6280): [CTFE] Cannot put 'in' expression of AA in an 'if' condition)
	$(LI $(BUGZILLA 6281): [CTFE] A null pointer '!is null' returns 'true'.)
	$(LI $(BUGZILLA 6282): [CTFE] ICE when dereferencing a pointer to reference type from 'in' of an AA)
	$(LI $(BUGZILLA 6283): [CTFE][Regression 2.054] Failed to assign to AA using a constness-changed array as key)
	$(LI $(BUGZILLA 6284): [Regression 2.054] 'pure' does not work with 'with' statement)
	$(LI $(BUGZILLA 6286): Regression(2.054): Static arrays can not be assigned from const(T)[N] to T[N])
	$(LI $(BUGZILLA 6293): [Regression 2.054] The expression x.y makes the function impure when the 'x' part is not just a variable)
	$(LI $(BUGZILLA 6295): [Regression 2.054] Segfault in checkPurity() of template value parameter)
	$(LI $(BUGZILLA 6306): Regression(2.054): [CTFE] Strange behavior of indirect recursive call in CTFE)
	$(LI $(BUGZILLA 6308): Destruction of temporaries on exception causes unhandled access violation)
	$(LI $(BUGZILLA 6316): Regression(2.054): Class downcast is rejected in @safe code)
	$(LI $(BUGZILLA 6317): ICE on struct literal of nested struct)
	$(LI $(BUGZILLA 6331): [CTFE] Cannot evaluate SliceExp on if condition)
	$(LI $(BUGZILLA 6337): [CTFE] ICE when touching member variable of struct during CTFE)
	$(LI $(BUGZILLA 6344): [CTFE] Assertion Failure in interpret.c when create an empty slice from null pointer)
	$(LI $(BUGZILLA 6351): Regression(2.054) Segfault: Vararg delegate as template param)
	$(LI $(BUGZILLA 6355): Template constructor cannot initialize non-mutable field)
	$(LI $(BUGZILLA 6366): alias this doesn't work with foreach range.front)
	$(LI $(BUGZILLA 6369): alias this doesn't work with initializer)
	$(LI $(BUGZILLA 6374): [CTFE] Cannot subscript using pointer to array)
	$(LI $(BUGZILLA 6375): [CTFE] Segfault when using std.array.appender with an initial array)
	$(LI $(BUGZILLA 6386): [CTFE] ICE on pointer casting)
	$(LI $(BUGZILLA 6389): Segfault(dsymbol.c): deprecated @disable)
	$(LI $(BUGZILLA 6399): [CTFE] struct member array.length -= x doesn't work, while array[0..$-x] works)
	$(LI $(BUGZILLA 6404): Cannot check ref-ness of auto ref parameter in template constraint)
	$(LI $(BUGZILLA 6418): [CTFE] Cannot call a struct member function with name 'length'.)
	$(LI $(BUGZILLA 6420): [CTFE] ICE on dereference-assigning to a pointer casted from a literal )
	$(LI $(BUGZILLA 6429): Nested function error in reduce)
	$(LI $(BUGZILLA 6433): Meta-Bug AA type propagation)
	$(LI $(BUGZILLA 6434): opDispatch must be considered before alias this.)
	$(LI $(BUGZILLA 6491): Fully qualified values in default arguments of non-template functions are generated with an extra 'module' keyword)
	$(LI $(BUGZILLA 6499): [GSoC] Destructor not called on object returned by method.)
	$(LI $(BUGZILLA 6505): Wrong code for expression involving 8 floats, only with -O)
	$(LI $(BUGZILLA 6508): alias this doesn't work with AssignExp rhs)
	$(LI $(BUGZILLA 6510): [CTFE] "internal error: illegal stack value" when compiled with -inline)
	$(LI $(BUGZILLA 6511): [CTFE] Array op gives wrong result)
	$(LI $(BUGZILLA 6512): [CTFE] new T[][] doesn't work)
	$(LI $(BUGZILLA 6516): Regression(2.055 beta) [CTFE] ICE(constfold.c) involving new dchar[])
	$(LI $(BUGZILLA 6517): [CTFE] ptr++ doesn't work but ++ptr does)
	$(LI $(BUGZILLA 6546): alias this + IdentityExpression doesn't work)
	$(LI $(BUGZILLA 6556): ICE for ImportStatement in DebugStatement)
	$(LI $(BUGZILLA 6558): [CTFE] UTF-decoding foreach gives wrong index (1-indexed))
	$(LI $(BUGZILLA 6561): alias this + undefined symbol should cause error)
	$(LI $(BUGZILLA 6563): wrong code when using at least 8 XMM regs)
	$(LI $(BUGZILLA 6577): 'Cannot initialize member' error line number)
	$(LI $(BUGZILLA 6601): Regression(2.053): CTFE segfault taking address of function template)
	$(LI $(BUGZILLA 6602): Invalid template instantiations leaked by is(typeof())/__traits(compiles, )/Type::trySemantic)
    )
)

$(VERSION 054, Jul 10, 2011, =================================================,

    $(WHATSNEW
	$(LI Implement @safe)
	$(LI Implement @property)
	$(LI Automatic inference for @safe, pure, nothrow)
	$(LI Allow labelled break and continue in CTFE)
	$(LI Warn about switch case fallthrough)
	$(LI Pointers are now supported in CTFE)
	$(LI Heap-allocated structs are now supported in CTFE)
	$(LI Added SSSE3 instructions to inline assembler)
	$(LI Change from warning to deprecated: non-final switch statements must have a default statement)
	$(LI Change from warning to deprecated: function is hidden by function)
	$(LI Add warning about switch case fallthrough)
	$(LI Add warning about calling pure nothrow functions and ignoring the result)
	$(LI Allow associative arrays with key of type bool)
	$(LI Added inference for purity and safety)
	$(LI Change win32 dmd to not emit a map file unless asked for with -map)
	$(LI Added $(B -property) switch)
	$(LI $(BUGZILLA 5823): @property call syntax restriction not implemented)

	$(LI Added core.sys.posix.netdb)
	$(LI For functions which have a version which takes a core.time.Duration
	     and another version which takes an integral value, the version which
	     takes an integral value is now scheduled for deprecation.)

        $(LI std.array.insertInPlace supports inserting of multiple ranges/elements in one go)
	$(LI Added std.array.uninitializedArray and std.array.minimallyInitializedArray)
        $(LI Various functions in std.string were renamed to match Phobos'
             naming conventions and be properly camelcased. The old names
             are still there but have been scheduled for deprecation.)
        $(LI Various functions in std.uni were renamed so that they don't have
             "Uni" in their name, since it was decided that it was not desirable to
             repeat a module's name in its functions' names. The old names
             are still there but have been scheduled for deprecation.)
        $(LI std.ctype has been scheduled for deprecation. std.ascii has been
             added to replace it.)
	$(LI Major performance improvements for std.algorithm.sort)
	$(LI std.string.atoi has been removed; replace it with std.conv.to!int)
	$(LI Switched to using posix.mak instead of various .mak files)
    )
    $(RUNTIMEBUGSFIXED
	$(LI $(BUGZILLA 4323): std.demangle incorrectly handles template floating point numbers)
	$(LI $(BUGZILLA 5272): Postblit not called on copying due to array append)
	$(LI $(BUGZILLA 5956): Undocumented mangling of struct value)
	$(LI $(BUGZILLA 6135): Thread/GC interaction bug on OS X)
    )
    $(LIBBUGSFIXED
        $(LI $(BUGZILLA 2108): regexp.d: The greedy dotstar isn't so greedy)
        $(LI $(BUGZILLA 3136): Incorrect and strange behavior of std.regexp.RegExp if using a pattern with optional prefix and suffix longer than 1 char)
        $(LI $(BUGZILLA 3457): rdmd fails silently in a particular setup where the compiler is not the expected)
        $(LI $(BUGZILLA 3479): writef/writefln: positional precision not working)
        $(LI $(BUGZILLA 3564): Rdmd failing to link external C libraries)
        $(LI $(BUGZILLA 3752): File.byLine fetches lines in a confusing manner)
        $(LI $(BUGZILLA 4367): std.regex: Captures is not a random access range)
        $(LI $(BUGZILLA 4574): std.regex: breaks with empy string regex)
        $(LI $(BUGZILLA 4608): std.string.chomp documentation mismatch implementation)
        $(LI $(BUGZILLA 5019): In std.regex, empty capture at end of string causes error)
	$(LI $(BUGZILLA 5059): String assignment in foreach loop breaks immutability)
	$(LI $(BUGZILLA 5458): scope for function parameters is not documented)
        $(LI $(BUGZILLA 5511): std.regex optional capture with no-match cause error)
	$(LI $(BUGZILLA 5598): rdmd does not fail on invalid filename)
        $(LI $(BUGZILLA 5673): Add lookahead and forgetful matching support std.regex)
        $(LI $(BUGZILLA 5705): Swapping identical struct with hasElaborateAssign causes "overlapping array copy" exception)
	$(LI $(BUGZILLA 5836): std.typetuple.staticIndexOf's example code missing %s in call to writefln)
        $(LI $(BUGZILLA 5857): std.regex (...){n,m} is bogus when (...) contains repetitions)
	$(LI $(BUGZILLA 5869): std.thread needs to be removed)
	$(LI $(BUGZILLA 6026): DLL example needs update due to missing core.dll_helper)
        $(LI $(BUGZILLA 6076): regression, std.regex: "c.*|d" matches "mm")
	$(LI $(BUGZILLA 6101): Documentation for dead modules still distributed with DMD)
        $(LI $(BUGZILLA 6113): singletons in std.datetime are not created early enough)
        $(LI $(BUGZILLA 6193): Appender.clear() functionality or documentation)
    )
    $(DMDBUGSFIXED
	$(LI $(BUGZILLA 693): 'this' can't be used as an alias parameter for a mixin)
	$(LI $(BUGZILLA 1373): typeof(func).stringof fails when func has parameters.)
	$(LI $(BUGZILLA 1411): ref Tuple should transform to Tuple of ref's)
	$(LI $(BUGZILLA 1570): Wrong return for address operator)
	$(LI $(BUGZILLA 2180): filename error with #line)
	$(LI $(BUGZILLA 2521): Not possible to return immutable value by ref)
	$(LI Temp destructors now called if exception is thrown)
	$(LI $(BUGZILLA 2625): Creating new struct with literal bypasses immutability of members if struct is in array)
	$(LI $(BUGZILLA 3147): Incorrect value range propagation for addition)
	$(LI $(BUGZILLA 3359): Cannot parse pure/const/immutable functions with inferred return type)
	$(LI $(BUGZILLA 3445): partial fix)
	$(LI $(BUGZILLA 3511): ref return property confused with property setter)
	$(LI $(BUGZILLA 3632): modify float is float to do a bitwise compare)
	$(LI $(BUGZILLA 3688): Can't have declaration with assignment to const/immutable inside if condition)
	$(LI $(BUGZILLA 3722): A method without an in contract should always succeed, even if overridden)
	$(LI $(BUGZILLA 3799): isStaticFunction trait evaluates to true for non-static nested functions)
	$(LI $(BUGZILLA 4031): Should be able to access const value-type globals from pure functions)
	$(LI $(BUGZILLA 4040): const/immutable on the right in auto return class methods)
	$(LI $(BUGZILLA 4063): [CTFE] key not found in AA gives bad error message)
	$(LI $(BUGZILLA 4065): [CTFE] AA "in" operator doesn't work)
	$(LI $(BUGZILLA 4107): Duplicate documentation for member function templates)
	$(LI $(BUGZILLA 4132): pointer arithmetic accepted in @safe functions)
	$(LI $(BUGZILLA 4170): Missing line number on compile-time array index)
	$(LI $(BUGZILLA 4258): "auto ref" doesn't work in one or more cases)
	$(LI $(BUGZILLA 4448): [CTFE] labeled break doesn't work in CTFE)
	$(LI $(BUGZILLA 4494): ICE(cod1.c) Array literal filled with results of void function)
	$(LI $(BUGZILLA 4633): typeof({return 1;}()) declaration fails if inside main)
	$(LI $(BUGZILLA 4661): Array Literal Incompatible Type Error Msg Should Include Line Number)
	$(LI $(BUGZILLA 4706): Overloading auto return w/ non-auto return = strange error msg)
	$(LI $(BUGZILLA 4745): Non-uniform handling of commas in static initialization of structs)
	$(LI $(BUGZILLA 4885): Uninitialize Pointers Allowed in @safe code)
	$(LI $(BUGZILLA 4910): [CTFE] Cannot evaluate a function that has failed at once)
	$(LI $(BUGZILLA 4963): ICE(type.c:320) for struct append where T.sizeof $(LESS) 3)
	$(LI $(BUGZILLA 4969): nothrow check can't handle multiple catches)
	$(LI $(BUGZILLA 5088): Cannot cast const(int) to long in @safe function)
	$(LI $(BUGZILLA 5258): [CTFE] Stack overflow with struct by ref)
	$(LI $(BUGZILLA 5284): Array ops punch through const system)
	$(LI $(BUGZILLA 5327): Creating new struct with literal bypasses immutability of members of members of the struct)
	$(LI $(BUGZILLA 5396): [CTFE] Invalid code with nested functions in CTFE)
	$(LI $(BUGZILLA 5415): @Safe functions not working)
	$(LI $(BUGZILLA 5497): -- now produces error message instead of wrong code)
	$(LI $(BUGZILLA 5551): opUnary-opBinary conflict)
	$(LI $(BUGZILLA 5574): Struct destructor freaks out when an array of struct with single element is instantiated inside a class)
	$(LI $(BUGZILLA 5615): [CTFE] std.string.indexOf broken at compile time)
	$(LI $(BUGZILLA 5633): [CTFE] ICE(constfold.c): is expression with struct, struct pointer, array literal...)
	$(LI $(BUGZILLA 5657): Temporary object destruction)
	$(LI $(BUGZILLA 5659): Conditional operator, array literal, and std.traits.CommonType return a wrong common type)
	$(LI $(BUGZILLA 5676): [CTFE] segfault using tuple containing struct that has opAssign)
	$(LI $(BUGZILLA 5682): [CTFE] Silently wrong result possibly related to operator overloading and expression order)
	$(LI $(BUGZILLA 5693): Segfault with address of template struct opCall)
	$(LI $(BUGZILLA 5708): [CTFE] Incorrect string constant folding with -inline)
	$(LI $(BUGZILLA 5771): Template constructor and auto ref do not work)
	$(LI $(BUGZILLA 5819): DMD doesn't error/warn about illegal asm for 64bit mode)
	$(LI $(BUGZILLA 5845): Regression(2.041) [CTFE] "stack overflow" with recursive ref argument)
	$(LI $(BUGZILLA 5856): overloading on const doesn't work for operator overload)
	$(LI $(BUGZILLA 5859): Declaration inside if condition doesn't call destructor)
	$(LI $(BUGZILLA 5861): Wrong filename in error message when an invalid delegate in a template parameter is typeof()-ed)
	$(LI $(BUGZILLA 5885): wrong codegen for OPu32_d)
	$(LI $(BUGZILLA 5897): unrelated struct type casting should ignite construction)
	$(LI $(BUGZILLA 5936): Invalid code with nested functions in CTFE)
	$(LI $(BUGZILLA 5946): failing lookup 'this' from function in template)
	$(LI $(BUGZILLA 5954): [CTFE] enum structs with ctor)
	$(LI $(BUGZILLA 5959): Return by reference with nested function should be allowed)
	$(LI $(BUGZILLA 5962): Template function declaration with prefixed storage class and auto occurs conflict)
	$(LI $(BUGZILLA 5963): iasm does not accept 64bit integer literal)
	$(LI $(BUGZILLA 6001): [CTFE] ICE(interpret.c) mutating ref array)
	$(LI $(BUGZILLA 6015): [CTFE] Strange behavior of assignment appears in a situation)
	$(LI $(BUGZILLA 6049): [CTFE] Array literals of structs with invariant() are wrong)
	$(LI $(BUGZILLA 6052): [CTFE] Struct elements in an array are treated like reference type)
	$(LI $(BUGZILLA 6053): [CTFE] Two ICEs involving pointers (dereference and assign; pointer variable on stack))
	$(LI $(BUGZILLA 6054): [CTFE] ICE when returning a returned compile-time associative array containing a key of an idup-ed array literal)
	$(LI $(BUGZILLA 6059): Incompatible types in array literal shows __error and error)
	$(LI $(BUGZILLA 6072): [CTFE] Regression(git master): Cannot declare variable inside an 'if' condition)
	$(LI $(BUGZILLA 6075): Cannot set value to associative array from a weakly-pure function when the value type has a (pure) opAssign)
	$(LI $(BUGZILLA 6077): [CTFE] Cannot append null array to null array.)
	$(LI $(BUGZILLA 6078): [CTFE] ICE on foreach over array struct member which is null)
	$(LI $(BUGZILLA 6079): [CTFE] Array index out of bound detection is off-by-one)
	$(LI $(BUGZILLA 6090): DDoc parenthesis escape issues.)
	$(LI $(BUGZILLA 6100): [CTFE] Regression: struct return values wrong if used in array initializer)
	$(LI $(BUGZILLA 6109): 'nothrow' does not check slice indices)
	$(LI $(BUGZILLA 6111): Escaping reference to local variable not detected)
	$(LI $(BUGZILLA 6119): Assertion failure: '0' on line 1118 in file 'glue.c')
	$(LI $(BUGZILLA 6120): [CTFE] ICE on calling constructor of template struct with -inline in function/delegate literal.)
	$(LI $(BUGZILLA 6123): [CTFE] Cannot call a template member method inside delegate/function literal with -inline.)
	$(LI $(BUGZILLA 6137): [CTFE] Foreach on semantically wrong initialized array crashes the compiler)
	$(LI $(BUGZILLA 6145): Meaningless second error message for complex size of static array)
	$(LI $(BUGZILLA 6150): runnable/testsocket.d)
	$(LI $(BUGZILLA 6158): winsamp and dhry samples need an update)
	$(LI $(BUGZILLA 6161): iasm opcode family Jcc use absolute address instead of relative for functions)
	$(LI $(BUGZILLA 6164): [CTFE] Local arrays in a recursive local function behave funny)
	$(LI $(BUGZILLA 6198): [GSoC] ICE(e2ir.c) With circular import)
	$(LI $(BUGZILLA 6229): %= and /= no longer work on char type)
	$(LI $(BUGZILLA 6230): Member functions can no longer be weakly pure)
	$(LI $(BUGZILLA 6234): 64-bit array append generates inline code to copy new data, but does not call postblit)
	$(LI $(BUGZILLA 6241): test sdtor.d on osx not catching)
	$(LI $(BUGZILLA 6242): Disallow inoperant "in" contracts)
	$(LI $(BUGZILLA 6264): ICE on testing opSlice in static if)
	$(LI $(BUGZILLA 6267): Can't increment alias this'd struct from ref return)
	$(LI $(BUGZILLA 6279): Regression(2.054 beta): array-vararg with pointer type not working in safe code)
    )
)

$(VERSION 053, May 12, 2011, =================================================,

    $(WHATSNEW
	$(LI Added 64 bit tools to Linux)
	$(LI Added FreeBSD support)
	$(LI Renamed linux/bin to linux/bin32, added linux/bin64)
	$(LI osx/lib32 renamed back to osx/lib)
	$(LI Added some gc benchmark apps)
	$(LI Move std.intrinsic to core.intrinsic)
	$(LI Implemented $(I exception chaining), as described in TDPL for Posix.)
	$(LI Added $(CODE parent) to $(CODE __traits) for QtD support)
	$(LI Allow impure code inside debug conditionals)
	$(LI Added cmpxchg16b, 64 bit bswap and movq instructions to internal assembler)
        $(LI Added bindings for libcurl: etc.c.curl)
        $(LI Added std.net.isemail)
	$(LI Added std.parallelism)
	$(LI Added support for positional parameter intervals, e.g. %1:3$s
	prints the first three parameters using the 's' format specifier)
	$(LI Added findSplit, findSplitBefore, findSplitAfter to std.algorithm;
	improved walkLength)
	$(LI Improved online documentation for std.algorithm)
	$(LI Added roundRobin, takeOne, and takeNone to std.range; improved
	stride)
	$(LI Added unsigned to std.traits)
	$(LI Removed std.iterator. Use either std.range.ElementType or std.range.ElementEncodingType
	depending on what you're trying to do.)
	$(LI $(BUGZILLA 2656): Remove octal literals)
	$(LI $(BUGZILLA 4097): Error: can only declare type aliases within static if conditionals)
	$(LI $(BUGZILLA 4360): Allow intrinsics in core.bitop to operate as intrinsics)
	$(LI $(BUGZILLA 4833): dmd -od doesn't make it to optlink's command line for map files)
    )
    $(RUNTIMEBUGSFIXED
	$(LI $(BUGZILLA 5612): core.cpuid not implemented on 64)
	$(LI $(BUGZILLA 1001): print stack trace (in debug mode) when program die)
	$(LI $(BUGZILLA 5847): Threads started by core.thread should have same floating point state as main thread)
    )
    $(LIBBUGSFIXED
        $(LI $(BUGZILLA 4644): assertExceptionThrown to assert that a particular exception was thrown)
        $(LI $(BUGZILLA 4944): Missing tzname even though we have tzset)
        $(LI $(BUGZILLA 5451): Three ideas for RedBlackTree)
        $(LI $(BUGZILLA 5474): unaryFun byRef is borked for custom parameter name)
        $(LI $(BUGZILLA 5485): TLS sections handled incorrectly in FreeBSD)
        $(LI $(BUGZILLA 5616): std.datetime: not cross-platform)
        $(LI $(BUGZILLA 5654): BigInt returns ZERO with strings of single digit number with leading zeros)
	$(LI $(BUGZILLA 5661): std.algorithm.move does not work on elaborate struct)
        $(LI $(BUGZILLA 5731): std.datetime.SysTime prints UTC offsets backwards)
        $(LI $(BUGZILLA 5761): std.datetime: Date.this(int day) conversion fails for Dec 30 of leap years)
        $(LI $(BUGZILLA 5780): [patch] std.traits.hasIndirections incorrectly handles static arrays)
        $(LI $(BUGZILLA 5781): std.datetime: On Windows, times off by one hour in some years due to DST rule changes)
        $(LI $(BUGZILLA 5794): std.datetime StopWatch (and perhaps benchmark) examples need a small fix)
        $(LI $(BUGZILLA 5928): Bigint modulo problem -- critical wrong-code bug)
     )
    $(DMDBUGSFIXED
	$(LI $(RED Note:) Although temporaries are destroyed now, they are not destroyed when
	exceptions are thrown. This is scheduled to be fixed.)
	$(LI $(BUGZILLA 2436): Unexpected OPTLINK termination EIP = 00425303 with /co)
	$(LI $(BUGZILLA 3372): optlink silently mistreats object files with more than 16384 symbols)
	$(LI $(BUGZILLA 4275): Unexpected optlink termination when 'export' attribute is missing)
	$(LI $(BUGZILLA 4808): UNEXPECTED OPTLINK TERMINATION AT EIP=0042787B)
	$(LI $(BUGZILLA 5670): Optlink 8.00.11 crash)

	$(LI $(BUGZILLA 937): C-style variadic functions broken)
	$(LI $(BUGZILLA 1330): Array slicing does not work the same way in CTFE as at runtime)
	$(LI $(BUGZILLA 1336): Inconsistent __traits usage)
	$(LI $(BUGZILLA 1389): Can't use mixin expressions when start of a statement.)
	$(LI $(BUGZILLA 1880): templates instantiated with non-constants should fail sooner)
	$(LI $(BUGZILLA 2257): Template value parameters behave like alias parameters)
	$(LI $(BUGZILLA 2414): enum is dynamically evaluated, yum)
	$(LI $(BUGZILLA 2526): non-const initializer to constant accepted inside template)
	$(LI $(BUGZILLA 2706): invalid template instantiation (and declaration?) is not rejected)
	$(LI $(BUGZILLA 2733): Unclear semantics of template value parameters)
	$(LI $(BUGZILLA 2841): char[] incorrectly accepted as a template value argument in D2)
	$(LI $(BUGZILLA 2850): bad codegen for struct static initializers)
	$(LI $(BUGZILLA 2990): TypeInfo.init() returns invalid array)
	$(LI $(BUGZILLA 3086): TypeInfo opEquals returns incorrect results)
	$(LI $(BUGZILLA 3214): Incorrect DWARF line number debugging information on Linux)
	$(LI $(BUGZILLA 3271): Struct initializers silently fail)
	$(LI $(BUGZILLA 3516): Destructor not called on temporaries)
	$(LI $(BUGZILLA 3792): Regression(1.053) "non-constant expression" for a template inside a struct using a struct initializer)
	$(LI $(BUGZILLA 3779): ["123"][0][$-1] causes __dollar unresolved in compile-time)
	$(LI $(BUGZILLA 3801): CTFE: this.arr[i] cannot be evaluated at compile time for structs)
	$(LI $(BUGZILLA 3835): ref foreach does not work in CTFE)
	$(LI $(BUGZILLA 4033): Error: base class is forward referenced)
	$(LI $(BUGZILLA 4050): [CTFE] array struct member slice update)
	$(LI $(BUGZILLA 4051): [CTFE] array struct member item update)
	$(LI $(BUGZILLA 4097): Error: can only declare type aliases within static if conditionals)
	$(LI $(BUGZILLA 4140): Error: non-constant expression "hello"[1u..__dollar])
	$(LI $(BUGZILLA 4298): Constant array translated to unnecessary array literal creation)
	$(LI $(BUGZILLA 4322): "void initializer has no value" on struct/union members initialized to "void")
	$(LI $(BUGZILLA 4329): Do not show error messages that refer to __error)
	$(LI $(BUGZILLA 4360): Allow intrinsics in core.bitop to operate as intrinsics)
	$(LI $(BUGZILLA 4437): copy construction bug with "return this;")
	$(LI $(BUGZILLA 4499): calls to @disabled postblit are emitted)
	$(LI $(BUGZILLA 4543): Regression(1.054, 2.038) typedef causes circular definition and segfault)
	$(LI $(BUGZILLA 4750): fail_compilation/fail225.d causes dmd to segv)
	$(LI $(BUGZILLA 4815): CodeView: Global and Static symbols should have unmangled names)
	$(LI $(BUGZILLA 4817): CodeView: Enum members should have simple names)
	$(LI $(BUGZILLA 4833): dmd -od doesn't make it to optlink's command line for map files)
	$(LI $(BUGZILLA 4917): Symbol conflict error message refers to aliased symbol instead of the alias)
	$(LI $(BUGZILLA 5147): [CTFE] Return fixed-size matrix)
	$(LI $(BUGZILLA 5268): Outdated windows GUI sample in Samples folder)
	$(LI $(BUGZILLA 5362): checking $ in bracket is broken)
	$(LI $(BUGZILLA 5482): Crash with align(0))
	$(LI $(BUGZILLA 5485): TLS sections handled incorrectly)
	$(LI $(BUGZILLA 5524): [CTFE] Trouble with typesafe variadic function)
	$(LI $(BUGZILLA 5647): [64-bit] Valgrind complains about illegal instruction)
	$(LI $(BUGZILLA 5649): std.conv.parse faulty for floating point with -O -m32)
	$(LI $(BUGZILLA 5657): Temporary object destruction)
	$(LI $(BUGZILLA 5664): Cannot compile static synchronized member function.)
	$(LI $(BUGZILLA 5694): va_arg doesn't work with idouble and ifloat)
	$(LI $(BUGZILLA 5671): CTFE string concat problem)
	$(LI $(BUGZILLA 5672): ICE(cod2.c): incorrect optimization of (long &1) == 1)
	$(LI $(BUGZILLA 5678): new enum struct re-allocated at compile time)
	$(LI $(BUGZILLA 5694): va_arg doesn't work with idouble and ifloat)
	$(LI $(BUGZILLA 5706): Incorrect opcode prefix generated for x86_64 inline assembly)
	$(LI $(BUGZILLA 5708): Incorrect string constant folding with -inline)
	$(LI $(BUGZILLA 5717): 1.067 regression: appending Unicode char to string broken)
	$(LI $(BUGZILLA 5722): Regression(2.052): Appending code-unit from multi-unit code-point at compile-time gives wrong result)
	$(LI $(BUGZILLA 5735): non-scalar types implicitly converted to boolean)
	$(LI $(BUGZILLA 5740): Unable to use this pointer in inline assembly)
	$(LI $(BUGZILLA 5741): Add the SYSCALL and SYSRET opcodes to the inline assembler)
	$(LI $(BUGZILLA 5798): Weakly pure function calls skipped inside a comma expression)
	$(LI $(BUGZILLA 5812): Added constant fold optimisations for ^^ expressions)
	$(LI $(BUGZILLA 5840): Cannot assign to an array member of struct in CTFE)
	$(LI $(BUGZILLA 5852): CTFE: wrong code for string[] ~= const(string))
	$(LI $(BUGZILLA 5858): Import doesn't accept const string as argument)
	$(LI $(BUGZILLA 5865): __dollar cannot be read at compile time)
	$(LI $(BUGZILLA 5890): ICE and wrong scope problem for 2nd argument in static assert with DMD on git master)
	$(LI $(BUGZILLA 5916): DMD: bad message for incorrect operands error)
	$(LI $(BUGZILLA 5938): ICE ztc\symbol.c 1043)
	$(LI $(BUGZILLA 5940): Cannot create arrays of std.algorithm.map)
	$(LI $(BUGZILLA 5965): [2.053 beta] map rejects a predicate with anon-func and nested func)
	$(LI $(BUGZILLA 5966): [2.053 beta][CTFE] Stack overflow on trivial func)
	$(LI $(BUGZILLA 5972): CTFE: Can't assign to elements of arrays of slices)
	$(LI $(BUGZILLA 5975): [2.053 beta][CTFE] ICE: 'global.errors' on line 1416 in file 'constfold.c')
	$(LI $(BUGZILLA 5976): "variable used before set" with foreach with ref + scope(failure) + structure method + -O -inline)
	$(LI $(BUGZILLA 5982): [2.053 beta] std.iterator gone, but no mention of the change)
	$(LI $(BUGZILLA 5987): mydll sample doesn't compile)
	$(LI Clarify tuple index out of bounds error message)
	$(LI Add 64 version of xchg and jmp to inline assembler. Fixed 64 bit LEA)
	$(LI CTFE: Generate error messages for accessing null arrays)
	$(LI Fix optimizer bug with to!float("123e2"))
	$(LI Fix spelling of $(CODE cmpxchgb8))
    )
)

$(VERSION 052, Feb 17, 2011, =================================================,

    $(WHATSNEW
	$(LI 64 bit support for Linux)
	$(LI Implemented $(I exception chaining), as described in TDPL. Currently Windows-only.)
	$(LI std.random: Added Xorshift random generator)
	$(LI Support HTML5 entities)
	$(LI Added std.datetime for handling dates and times. std.date and std.gregorian
	     are now scheduled for deprecation. Any functions in other modules of Phobos
	     which used std.date.d_time have been changed to use std.datetime.SysTime or
	     are scheduled for deprecation with new functions with the same functionality
	     added which use SysTime (done in cases where switching existing functions to
	     use SysTime would have broken code). New code should use std.datetime instead
	     of std.date.)
	$(LI Various functions in std.file were renamed to match Phobos' naming
	     conventions (e.g. isFile instead of isfile). The old names are aliased
	     and scheduled for deprecation.)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 190): Cannot forward reference typedef/alias in default value for function parameter)
	$(LI $(BUGZILLA 1513): try/catch/finally misbehavior on windows)
	$(LI $(BUGZILLA 1899): AA of fixed-length arrays fails to initialize)
	$(LI $(BUGZILLA 1914): Array initialisation from const array yields memory trample)
	$(LI $(BUGZILLA 2581): DDoc doesn't work for functions with auto return type.)
	$(LI $(BUGZILLA 2810): Bogus forward reference error with auto function)
	$(LI $(BUGZILLA 2874): phobos docs issues)
	$(LI $(BUGZILLA 3198): wrong initializer for structs arrays)
	$(LI $(BUGZILLA 3334): std.demangle doesn't parse ref, pure, nothrow)
	$(LI $(BUGZILLA 3681): ICE(go.c): when function takes too long to optimize, only with -O.)
	$(LI $(BUGZILLA 3848): functions in std.file don't take symbolic links into account)
	$(LI $(BUGZILLA 4013): Inconsistent codeview debug info for classes derived from IUnknown)
	$(LI $(BUGZILLA 4069): Issue 4069 - std.xml.Document.pretty saves empty elements with spaces and line breaks)
	$(LI $(BUGZILLA 4245): Declaring conflicting symbols in single function scope allowed)
	$(LI $(BUGZILLA 4307): spawn()'ed thread doesn't terminate)
	$(LI $(BUGZILLA 4328): templated unittests fail to link when instantiated from other file if compiler order isn't correct)
	$(LI $(BUGZILLA 4379): ICE(blockopt.c): foreach over huge tuple, only with -O)
	$(LI $(BUGZILLA 4389): ICE(constfold.c, expression.c), or wrong code: string~=dchar in CTFE)
	$(LI $(BUGZILLA 4486): CodeView debug info should contain absolute path names)
	$(LI $(BUGZILLA 4598): std.xml check is too restrictive)
	$(LI $(BUGZILLA 4601): Spawned threads frequently don't terminate or let other threads ever run if you spawn more than one thread)
	$(LI $(BUGZILLA 4732): __traits(identifier) performs constant folding on symbols)
	$(LI $(BUGZILLA 4753): fail_compilation/fail116.d sends dmd into a loop, exhausting memory)
	$(LI $(BUGZILLA 4807): Examples for std.array insert and replace)
	$(LI $(BUGZILLA 4852): core.demangle cannot demangle functions with class/struct return types)
	$(LI $(BUGZILLA 4878): Ddoc: Default arguments can break Ddoc output)
	$(LI $(BUGZILLA 4913): Implicit opCast!bool in if statement doesn't work with declarator)
	$(LI $(BUGZILLA 4973): map file with spaces in file name passed without quotes to linker)
	$(LI $(BUGZILLA 5025): ICE(cast.c) shared struct literal)
	$(LI $(BUGZILLA 5090): ICE(todt.c) struct literal initializing zero length array)
	$(LI $(BUGZILLA 5105): Member function template cannot be synchronized)
	$(LI $(BUGZILLA 5197): Ddoc: access-attributed auto template function crashes dmd)
	$(LI $(BUGZILLA 5198): Appender much slower when appending ranges of elements than individual elements)
	$(LI $(BUGZILLA 5209): posix/sys/select.d: FD_ISSET function should return bool)
	$(LI $(BUGZILLA 5221): entity.c: Merge Walter's list with Thomas')
	$(LI $(BUGZILLA 5242): self referencing template constraint crashes compiler)
	$(LI $(BUGZILLA 5244): PATCH: fix use of uninitialised variable in toObj.c)
	$(LI $(BUGZILLA 5246): PATCH(s): fix a couple more uninitialised variables)
	$(LI $(BUGZILLA 5248): CTFE Segfault when calling a function on an enum struct)
	$(LI $(BUGZILLA 5271): Not constant RAND_MAX)
	$(LI $(BUGZILLA 5320): gcstub/gc.d: SEGV because of missing returns)
	$(LI $(BUGZILLA 5349): ICE(toir.c): nested class in static member function)
	$(LI $(BUGZILLA 5365): Regression (2.051) implicit conversions via alias this are broken)
	$(LI $(BUGZILLA 5381): Regression (2.051) switch fails for wstring and dstring)
	$(LI $(BUGZILLA 5382): [regression 2.051] DLL multi-threading broken)
	$(LI $(BUGZILLA 5391): Crash with recursive alias declaration)
	$(LI $(BUGZILLA 5400): Add const to FD_ISSET)
	$(LI $(BUGZILLA 5439): 64bit struct alignment inconsistent with C ABI)
	$(LI $(BUGZILLA 5447): Should be illegal to throw a non-Throwable)
	$(LI $(BUGZILLA 5455): ICE(cgcod.c): Optimization (register allocation?) regression in DMD 1.065)
	$(LI $(BUGZILLA 5486): Missing define for running dmd as 64 bit)
	$(LI $(BUGZILLA 5488): Spawned threads hang in a way that suggests allocation or gc issue)
	$(LI $(BUGZILLA 5504): Regression(2.051): Template member functions of a shared class don't compile)
	$(LI $(BUGZILLA 5534): [64-bit] Inexplicable segfault in small code snippet, -O -release -m64 only)
	$(LI $(BUGZILLA 5536): Array append with dollar op on 64-bit)
	$(LI $(BUGZILLA 5545): [64-bit] DMD fails to postincrement ubytes.)
	$(LI $(BUGZILLA 5549): [64-bit] Internal error: backend/cgcod.c 1845)
	$(LI $(BUGZILLA 5552): std.datetime.d DosFileTimeToSysTime has a bug)
	$(LI $(BUGZILLA 5556): [64-bit] Wrong Implicit Conversion to Double)
	$(LI $(BUGZILLA 5557): [64-Bit] FP (alignment?) issues with Rvalues)
	$(LI $(BUGZILLA 5564): [64-bit] loading of wrong constant byte value)
	$(LI $(BUGZILLA 5565): [64-bit] Wrong Floating Point Results, Related to Mixing With size_t)
	$(LI $(BUGZILLA 5566): [64-bit] More erratic FP results with size_t)
	$(LI $(BUGZILLA 5579): Segfault on first call to GC after starting new thread)
	$(LI $(BUGZILLA 5580): [64-bit] String switch statements broken in 64-bit mode)
	$(LI $(BUGZILLA 5581): [64-bit] Wrong code with bitwise operations on bools)
	$(LI $(BUGZILLA 5592): Previous definition different: __arrayExpSliceMulSliceAddass_d)
	$(LI $(BUGZILLA 5595): Compiler crash on heavy std.algorithm use)
    )
)

$(VERSION 051, Dec 21, 2010, =================================================,

    $(WHATSNEW
	$(LI Added std.mathspecial, containing mathematical Special Functions)
	$(LI std.base64: Replaced. Boost License, Performance improvement, Range support. Function signature changed from 'encode' to 'Base64.encode')
	$(LI std.math: D implementation of pow. Almost all std.math functions are now @safe pure nothrow.
	     tgamma, lgamma, erf, erfc have been moved to std.mathspecial)
	$(LI std.exception: Added pure and nothrow to assumeUnique)
	$(LI std.utf: Removed UtfError class and toUTF* shortcut functions for validation. Added pure, nothrow, @safe and @trusted attributes. count function supports dchar)
	$(LI Both druntime and phobos now build successfully with dmd -m64. Still somewhat behind dmd1, very little executes correctly still.)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 603): Undocumented behaviour: case and default create a scope)
	$(LI $(BUGZILLA 632): Typedef/enum promotions spec ambiguous - ultimate base type or lowest common denominator?)
	$(LI $(BUGZILLA 679): Spec needs allowances for copying garbage collection)
	$(LI $(BUGZILLA 690): ABI not fully documented)
	$(LI $(BUGZILLA 1351): Discrepancies in the language specification)
	$(LI $(BUGZILLA 1466): Spec claims maximal munch technique always works: not for "1..3")
	$(LI $(BUGZILLA 2080): ICE(mangle.c) alias corrupts type inference of static variables)
	$(LI $(BUGZILLA 2206): unnamed template mixin of class inside function or class has incorrect classinfo and mangleof)
	$(LI $(BUGZILLA 2385): spec says all structs are returned via hidden pointer on linux, but it uses registers)
	$(LI $(BUGZILLA 2392): Parsing ambiguity between function pointer declaration and function call)
	$(LI $(BUGZILLA 2406): Declarator2 definition error)
	$(LI $(BUGZILLA 2556): Property classinfo needs better documentation (RTTI, typeof, typeid, runtime type information))
	$(LI $(BUGZILLA 2616): Undocumented behaviour: part-explicit, part-implicit instantiations of function templates are accepted)
	$(LI $(BUGZILLA 2651): class body declaration grammar incorrect)
	$(LI $(BUGZILLA 2652): DeclDef grammar is wrong)
	$(LI $(BUGZILLA 2734): Ambiguity in tokenizing: _._ as a float literal)
	$(LI $(BUGZILLA 2751): const/invariant/immutable static arrays: const(T)[N] and const(T[N]) are the same, but DMD treats them as different)
	$(LI $(BUGZILLA 2954): [tdpl] Appalling bug in associative arrays (D2 only))
	$(LI $(BUGZILLA 2994): Incomplete "Predefined Versions" documentation)
	$(LI $(BUGZILLA 3020): No description is given why function may not be nothrow)
	$(LI $(BUGZILLA 3112): Specification on what operations call the GC is missing)
	$(LI $(BUGZILLA 3276): Recursion broken by alias template parameter)
	$(LI $(BUGZILLA 3554): Ddoc generates invalid output for documentation comments with non paired parentheses)
	$(LI $(BUGZILLA 3864): Dyn array allocations can be allowed in nothrow functions)
	$(LI $(BUGZILLA 4059): Incorrect C++ name mangling)
	$(LI $(BUGZILLA 4217): Function overloads are not distinguished when instantiating templates)
	$(LI $(BUGZILLA 4254): ICE(mtype.c): function with const inout parameter)
	$(LI $(BUGZILLA 4297): Nothrow functions cannot use constant dynamic array)
	$(LI $(BUGZILLA 4384): Cyclic dependency check for modules is broken)
	$(LI $(BUGZILLA 4434): ICE(mtype.c, 887) alias with const, shared, or immutable)
	$(LI $(BUGZILLA 4445): roundTo!ubyte(255.0) throws)
	$(LI $(BUGZILLA 4529): Segfault(typinf.c) involving typeid(typeof(functionName)))
	$(LI $(BUGZILLA 4638): Regression: new writeln does not recognize "wstring toString")
	$(LI $(BUGZILLA 4728): Segfault(toctype.c) by protected/private constructor in an other module)
	$(LI $(BUGZILLA 4781): Segfault(mtype.c) with forward referenced typeof and .init)
	$(LI $(BUGZILLA 4864): ICE(statement.c) Crash on invalid 'if statement' body inside mixin)
	$(LI $(BUGZILLA 4901): std.algorithm.sort does not compile for interfaces.)
	$(LI $(BUGZILLA 4915): auto return type escapes function purity)
	$(LI $(BUGZILLA 5020): Forward implicit bool conversions to alias this)
	$(LI $(BUGZILLA 5053): Better error message for cyclic dependencies.)
	$(LI $(BUGZILLA 5054): Splitter example doesn't work)
	$(LI $(BUGZILLA 5094): No implicit conversion with "alias property this")
	$(LI $(BUGZILLA 5107): Const-shared classes/structs not typed as shared)
	$(LI $(BUGZILLA 5110): Excess attribute propagation of structs and classes)
	$(LI $(BUGZILLA 5117): [CTFE] Member function call with rather complex this: side effects ignored)
	$(LI $(BUGZILLA 5120): ICE(mtype.c) void associative arrays)
	$(LI $(BUGZILLA 5131): Segfault(expression.c) opAssign and associative arrays (AA) are broken for types != this)
	$(LI $(BUGZILLA 5133): dmd fails to build rdmd (problem with startsWith))
	$(LI $(BUGZILLA 5145): Regression(2.050, 1.065) override error with forward ref of superclass)
	$(LI $(BUGZILLA 5148): Incorrect C++ mangling of multiple const char* parameters)
	$(LI $(BUGZILLA 5154): Class Range does not work in writeln)
	$(LI $(BUGZILLA 5159): Segfault(interpret.c): calling a static function pointer variable in CTFE)
	$(LI $(BUGZILLA 5163): meaningless error message with front() applied to void[].)
	$(LI $(BUGZILLA 5164): Error without line number using "is (T...)")
	$(LI $(BUGZILLA 5180): ICE(arrayop.c) in-place array operation on incompatible types)
	$(LI $(BUGZILLA 5182): ICE(expression.c): calling unittest from a function)
	$(LI $(BUGZILLA 5191): Combination of pure and nothrow result in a function that does nothing)
	$(LI $(BUGZILLA 5194): ddoc does not show modifiers on constructors such as pure or nothrow)
	$(LI $(BUGZILLA 5195): Forward references ignore const)
	$(LI $(BUGZILLA 5214): Compiler crash with array of empty {})
	$(LI $(BUGZILLA 5218): Can't implicitly convert from "abc"w to wchar[3])
	$(LI $(BUGZILLA 5220): Make std.conv.ConvError an Exception instead of an Error; $(RED deprecated ConvError and ConvOverflowError) with ConvException and ConvOverflowException. Note that any code depending on the fact that these exceptions were Error gets broken.)
	$(LI $(BUGZILLA 5230): Regression(2.041, 1.057) ICE(tocsym.c) overriding a method that has an out contract)
	$(LI $(BUGZILLA 5238): PATCH: fix return of uninitialised var in interpret.c)
	$(LI $(BUGZILLA 5247): std.utf.stride() should not return 0xFF)
	$(LI $(BUGZILLA 5275): x86_64 related hidden function parameter mishandled)
	$(LI $(BUGZILLA 5293): std.math: Error: shift by -48 is outside the range 0..32)
	$(LI $(BUGZILLA 5294): -O optimization breaks for loop)
	$(LI $(BUGZILLA 5321): std.math: assumes X86 or X86_64 on FPU control word code)
	$(LI $(BUGZILLA 5322): std.math: version(Sparc) should be SPARC)
	$(LI $(BUGZILLA 5330): Druntime/Phobos: remove special treatment for GDC)
	$(LI $(BUGZILLA 5331): mach format problem)
	$(LI $(BUGZILLA 5340): isOutputRange!(Appender!string, int) must be false)
	$(LI $(BUGZILLA 5353): clear function is calling the destructor twice)
    )
)

$(VERSION 050, Oct 29, 2010, =================================================,

    $(WHATSNEW
	$(LI added talign() and argTypes() to TypeInfo)
	$(LI Upgrade zlib support to zlib 1.2.5)
	$(LI std.stdio:  Added ByChunk. This struct is a InputRange like ByLine. File.byChunk returns ByChunk)
	$(LI std.traits:  Most higher-order ranges now work with const/immutable arrays and other ranges
	with a natural tail const, and ranges w/ const/immutable elements.)
	$(LI $(BUGZILLA 4888):  Heavy reliance on Bug 3534 in Phobos range usage)
	$(LI $(BUGZILLA 4987): C function pointer syntax needs to be deprecated)
	$(LI std.typecons:  Several improvements to the Tuple struct template:
	    $(UL $(LI  Tuple members are now accessible with the syntax a[0], a[1] etc.)
	         $(LI  Eliminated an internal union. See $(BUGZILLA 4421) and $(BUGZILLA 4846).)
	         $(LI  Worked around $(BUGZILLA 4424). Got opAssign back.)
	         $(LI  Made Tuple.slice!(from, to) to preserve field names if any.)
	         $(LI  Added isTuple!(T) template.)
	    ))
	$(LI std.algorithm: changed filter() such that filter is curryable)
	$(LI std.algorithm: Added function balancedParens)
    $(LI std.typecons: Deprecated defineEnum)
	$(LI Added relaxed purity checking rules.)
    )
    $(BUGSFIXED
	$(LI Unlisted bug:  std.exception.pointsTo() calls postblit on subobjects.)
	$(LI Unlisted bug:  std.typetuple.staticMap!() doesn't work with empty/single tuples.)
	$(LI Unlisted bug:  std.traits:  Interfaces should have indirections, aliasing, etc.)
	$(LI Unlisted bug:  std.socket:  Race condition - gethostbyname and gethostbyaddr on Linux return static data.  The call was synchronized, but using the data wasn't)
	$(LI Unlisted bug:  signed long comparisons under OS X)
	$(LI $(BUGZILLA 941): std.regexp fails to match when grouping certain sub-expressions)
	$(LI $(BUGZILLA 1482): std.file docs are insufficient)
	$(LI $(BUGZILLA 1635): DirEntry.isfile() and DirEntry.isdir() broken)
	$(LI $(BUGZILLA 1733): parse() function does not handle all build-in types)
	$(LI $(BUGZILLA 2073): Variant.coerce!() fails)
	$(LI $(BUGZILLA 2142): getopt() incorrectly processes bundled command-line options)
	$(LI $(BUGZILLA 2310): Inconsistent formatting of arrays in std.stdio.write() and std.conv.to!(string)())
	$(LI $(BUGZILLA 2424): std.functional binaryRevertArgs : "revert" should be "reverse")
	$(LI $(BUGZILLA 2451): Adding structs that use opAssign or postblit to an AA is broken)
	$(LI $(BUGZILLA 2655): Allow alternation patterns in std.path.fnmatch)
	$(LI $(BUGZILLA 2669): Variant does not have opApply or another iteration mechanism)
	$(LI $(BUGZILLA 2718): Inconsistent string parameters in Phobos functions)
	$(LI $(BUGZILLA 2838): std.file.rmdirRecurse fails)
	$(LI $(BUGZILLA 2930): Problems in std.range documentation)
	$(LI $(BUGZILLA 2943): Struct copying in presence of alias member this only copies alias this member)
        $(LI $(BUGZILLA 2965): std.date: timezone not initialized)
        $(LI $(BUGZILLA 3157): [patch] Pipes should be closed with pclose)
        $(LI $(BUGZILLA 3318): [PATCH]Rebindable.get is not accessible)
	$(LI $(BUGZILLA 3570): mkdirRecurse throws exception on trailing empty directory.)
	$(LI $(BUGZILLA 3602): ICE(tocsym.c) compiling a class, if its super class has preconditions)
	$(LI $(BUGZILLA 3665): Regression(1.051, 2.036) Assignment with array slicing does not work)
	$(LI $(BUGZILLA 4344): Sockets with multiple threads report missing/failed WSAStartup)
	$(LI $(BUGZILLA 4398): dmd always uses Windows name mangling for _d_throw)
	$(LI $(BUGZILLA 4439): The declaration of the in6addr_* in druntime is wrong.)
	$(LI $(BUGZILLA 4465): ICE(symbol.c): immutable type inference with ^^2)
	$(LI $(BUGZILLA 4524): Regression(2.026) Bus error with nested struct)
	$(LI $(BUGZILLA 4623): Non-integer type allowed as static array size)
	$(LI $(BUGZILLA 4634): typo in levenshteinDistanceAndPath documentation)
	$(LI $(BUGZILLA 4641): Associative arrays of structs with alias this broken.)
	$(LI $(BUGZILLA 4742): int % BigInt should work.)
	$(LI $(BUGZILLA 4775): No substitution on writef("%%%s", "hi").)
	$(LI $(BUGZILLA 4825): Regression(1.057, 2.040) "Error: non-constant expression" with -inline)
	$(LI $(BUGZILLA 4866): Static-to-dynamic converted manifest constant array gets non-converted type in static/constraint if)
	$(LI $(BUGZILLA 4869): auto return + inheritance + modules = compiler crashes(toctype.c))
	$(LI $(BUGZILLA 4873): Assertion failure: '0' on line 1483 in file 'expression.c')
	$(LI $(BUGZILLA 4882): std.traits hasUnsharedAliasing does not work for function type.)
	$(LI $(BUGZILLA 4897): CodeView: No locals or parameters are shown when debugging, because of missing function info)
	$(LI $(BUGZILLA 4890): GC.collect() deadlocks multithreaded program.)
	$(LI $(BUGZILLA 4925): [ICE] segfault with module-scope assert(0))
	$(LI $(BUGZILLA 4926): ICE: PREC_zero assertion failure due to unset precedence)
	$(LI $(BUGZILLA 4938): Regression(2.047) dmd segfault when compiling)
	$(LI $(BUGZILLA 4941): Built-in tuple slice boundaries are not CTFE'd)
	$(LI $(BUGZILLA 4949): ICE on invalid static if using value of 'this')
	$(LI $(BUGZILLA 4951):  InternetAddress fails to resolve host when multithreading.)
	$(LI $(BUGZILLA 4959): std.conv.parse error "no digits seen" on string starting with zero.)
	$(LI $(BUGZILLA 4992): ICE(glue.c) or segfault: using int[new])
	$(LI $(BUGZILLA 5003): regex(replace with delegate) sample doesn't work.)
	$(LI $(BUGZILLA 5026): ICE(expression.c) Incomplete mixin expression + char[] to char assignment)
	$(LI $(BUGZILLA 5049): std.algortihm.bringToFront() returns wrong value.)
	$(LI $(BUGZILLA 5052): take!(Take!R) should return Take!R, not Take!(Take!R).)
	$(LI $(BUGZILLA 5071): passing value by ref to a function with an inner dynamic closure results in a wrong code)
    )
)

$(VERSION 049, Sep 13, 2010, =================================================,


    $(WHATSNEW
	$(LI std.algorithm:  reduce now works with non-range-based iteration, such as opApply.)
	$(LI std.numeric:  Added FFT.)
	$(LI std.path:  Changed sep, altsep etc. to manifest constants (enum).)
	$(LI std.process: Added environment, an AA-like interface for environment variables.)
	$(LI std.range:  Iota, Stride, Transversal, FrontTransveral now support slicing where possible.)
	$(LI std.range:  Added support for moveFront() and assignable elements in several higher-order ranges.)
	$(LI std.range:  Added Lockstep, hasLvalueElements.)
	$(LI std.range:  Added virtual function-based wrappers (InputRangeObject, OutputRangeObject) for when a binary interface to a range is required.)
	$(LI std.typecons:  Added convenience functions for Rebindable.)
	$(LI std.traits:  Added isAssignable, isIterable, ForeachType, isSafe, isUnsafe, EnumMembers.)
	$(LI std.traits:  hasLocalAliasing, hasLocalObjects and hasLocalRawAliasing are now hasUnsharedAliasing, hasUnsharedObjects and hasUnsharedRawAliasing.  Aliases to the old names are included for now for backwards compatibility.)
	$(LI std.typetuple:  Added anySatisfy.)
	$(LI std.array:  Modified Appender's interface to fix memory issues.
	Note that appending via $(D ~=) and using appender on the same array
	will not interleave anymore.)
	$(LI $(BUGZILLA 2477): Trailing comma in array literal sometimes accepted, sometimes not)
    )
    $(BUGSFIXED
	$(LI Andrej Mitrovic updated the samples/d code)
	$(LI Unlisted Bug:  std.math.pow doesn't work on immutable numbers.)
	$(LI Unlisted Bug:  std.math.pow floating point overload expects both arguments to be exact same type.)
	$(LI Unlisted Bug:  std.path.join("", "foo") returns "/foo" instead of "foo" on Posix.)
	$(LI Unlisted Bug:  std.range.iota() random access primitives inconsistent after popFront on floating point version)
	$(LI Unlisted Bug:  std.algorithm.findAdjacent() [...])
	$(LIX $(BUGZILLA 190): Cannot forward reference typedef/alias in default value for function parameter)
	$(LI $(BUGZILLA 1715): Template specialization checks for equality rather than convertibility)
	$(LI $(BUGZILLA 1970): Templated interfaces not matched)
	$(LI $(BUGZILLA 2511): Covariant return type doesn't work with circular import)
	$(LI $(BUGZILLA 2716): Confusion of auto and scope as the class attribute)
	$(LI $(BUGZILLA 2903): Splitter should be bi-dir if the input range is bi-dir.)
	$(LI $(BUGZILLA 2951): std.random.dice() should be templated on proportions.)
	$(LI $(BUGZILLA 2958): std.getopt RangeError on missing arg)
	$(LI $(BUGZILLA 3046): Segfault with C++ static variable (Linux only))
	$(LI $(BUGZILLA 3123): std.algorithm.zip fails on 'lazy' ranges)
	$(LI $(BUGZILLA 3294): forward reference to inferred return type of function call)
	$(LI $(BUGZILLA 3312): std.string.count should use const(char)[], not immutable.)
	$(LI $(BUGZILLA 3348): Documentation for many std.process functions has disappeared)
	$(LI $(BUGZILLA 3361): code in std.zlib concatenates void[] arrays )
	$(LI $(BUGZILLA 3418): link error with cast(ulong)(ulong*real))
	$(LI $(BUGZILLA 3544): optlink termination 0041338f with recursive nested functions)
	$(LI $(BUGZILLA 3554): Ddoc generats invalid output for documentation comments with non paired paranthasis)
	$(LI $(BUGZILLA 3627): -of with a filename with a double extension confuses linker)
	$(LI $(BUGZILLA 3877): std.range.chain do not manage infinite ranges correctly)
	$(LI $(BUGZILLA 3894): std.range.Stride!R requires R.front() and R.back() to return by reference)
	$(LI $(BUGZILLA 3935): opBinary is instantiated with "=")
	$(LI $(BUGZILLA 3946): schwartzSort - SwapStrategy always unstable)
	$(LIX $(BUGZILLA 3979): Order-of-compilation and forward reference errors)
	$(LI $(BUGZILLA 3996): Regression(2.041) ICE(glue.c) Passing struct as AA template parameter (Algebraic with struct))
	$(LI $(BUGZILLA 4009): OPTLINK ruins the day yet again)
	$(LI $(BUGZILLA 4173): Regression(2.037) Explicitly instantiated templates still try to do IFTI in some cases)
	$(LI $(BUGZILLA 4177): __ctfe can't be used in pure functions)
	$(LI $(BUGZILLA 4278): allow inlining of super calls (undo limitations of bug3500's fix))
	$(LI $(BUGZILLA 4291): Pure functions cannot access mixed in variables)
	$(LI $(BUGZILLA 4292): CommonType fails for singular alias value.)
	$(LI $(BUGZILLA 4302): Regression(2.046, 1.061): compiler errors using startsWith in CTFE)
	$(LI $(BUGZILLA 4345): std.range.take!string: "Nonsensical finite range with slicing but no length".)
	$(LI $(BUGZILLA 4346): More flexible std.array.array.)
	$(LI $(BUGZILLA 4363): Some phobos ranges are not forward ranges (but should be).)
	$(LI $(BUGZILLA 4381): Length attribute for std.typecons.Tuple.)
	$(LI $(BUGZILLA 4387): std.range.Cycle assumes lvalue elements.)
	$(LI $(BUGZILLA 4388): std.range.Radial assumes lvalue elements.)
	$(LI $(BUGZILLA 4402): std.range.Zip doesn't work w/ non-lvalue ranges.)
	$(LI $(BUGZILLA 4403): std.range.FrontTransversal assumes lvalue elements.)
	$(LI $(BUGZILLA 4404): std.range.Transversal assumes lvalue elements.)
	$(LI $(BUGZILLA 4408): Ambiguity when using std.algorithm.splitter with generic ranges.)
	$(LI $(BUGZILLA 4430): Regression(2.037) erroneous matching on specialized template function)
	$(LI $(BUGZILLA 4455): Taking the sqrt of an integer shouldn't require an explicit cast.)
	$(LI $(BUGZILLA 4464): std.range.take does not always return Take!R.)
	$(LI $(BUGZILLA 4518): to!string(enum w/invalid value) produces a somewhat unhelpful error)
	$(LI $(BUGZILLA 4564): ICE on undefined variable in foreach over 0 .. undef)
	$(LI $(BUGZILLA 4603): array(iota(1, 0)) error.)
	$(LI $(BUGZILLA 4643): Shared values are unwritable.)
	$(LI $(BUGZILLA 4645): to!string(const char*) in library causes Optlink to issue warning)
	$(LI $(BUGZILLA 4652): Compiler hangs on template with zero-length tuple and another argument)
	$(LI $(BUGZILLA 4655): Regression(1.063, 2.048) goto to a try block ICEs)
	$(LI $(BUGZILLA 4676): Overload resolution rejects valid code when mixing variadics, non-variadics)
	$(LI $(BUGZILLA 4681): Appender access violation)
	$(LI $(BUGZILLA 4691): Incorrect comparison of double and long)
	$(LI $(BUGZILLA 4700): to!float("0") fails)
	$(LI $(BUGZILLA 4721): compilation slow when compiling unittests on dcollections)
	$(LI $(BUGZILLA 4748): Shadowing declaration error in std.string.tolower)
	$(LI $(BUGZILLA 4751): Regression(1.062, 2.047) ICE(constfold.c) >> after error)
	$(LI $(BUGZILLA 4752): fail_compilation/fail345.d asserts in expression.c)
	$(LI $(BUGZILLA 4771): fail_compilation/fail274.d hits a halt in iasm.c)
	$(LI $(BUGZILLA 4789): std.algorithm.sort bug)
	$(LI $(BUGZILLA 4810): dotProduct problem with ints)
	$(LI $(BUGZILLA 4826): Regression(2.041) "cannot create associative array" and compiler crash)
	$(LI $(BUGZILLA 4828): ICE w/ non-boolean dot expression sth.template_instance in static if)
	$(LI $(BUGZILLA 4834): Implicit sharing via delegates in std.concurrency)
    )
)


$(VERSION 048, Aug 8, 2010, =================================================,


    $(WHATSNEW
	$(LI std.complex: New Complex.toString() syntax.)
	$(LI std.string: icmp() now works with all built-in string types.)
	$(LI $(BUGZILLA 4077): Bugs caused by bitwise operator precedence)
	$(LI $(BUGZILLA 4080): Patch for building dynamic libraries on Mac OS X)
    )
    $(BUGSFIXED
	$(LI Unlisted Bug: std.algorithm.filter not a forward range)
	$(LI Unlisted Bug: std.algorithm.Uniq requires a bidirectional range)
	$(LI Unlisted Bug: std.algorithm.Uniq missing a save() function)
	$(LI Unlisted Bug: std.algorithm.Group missing a save() function)
	$(LI Unlisted Bug: std.traits.isAssociativeArray reports true for structs w/ keys, values properties)
	$(LI Unlisted Bug: gc_query returns 0 for attr when called on interior pointers)
	$(LI $(NG_digitalmars_D 112964): capacity can return a value $(LESS) length)
	$(LI $(BUGZILLA 978): std.utf's toUTF* functions accept some invalid and reject some valid UTF)
	$(LI $(BUGZILLA 996): Error in doc on implicit conversion between pointer and array)
	$(LI $(BUGZILLA 1418): tupleof bug on nested classes)
	$(LI $(BUGZILLA 1678): ref with varargs generates invalid code)
	$(LI $(BUGZILLA 2275): std.utf.toUTF16z() should return const(wchar)*)
	$(LI $(BUGZILLA 2627): std.traits.hasAliasing reports true for static arrays)
	$(LI $(BUGZILLA 2872): Length, opIndex for Map)
	$(LI $(BUGZILLA 2931): Initialization struct with array from another struct)
	$(LI $(BUGZILLA 3202): std.math.pow cause dead loop)
	$(LI $(BUGZILLA 3326): $ in delegate literal causes Access Violation)
	$(LI $(BUGZILLA 3355): std.string.cmp works incorrectly for mixed-type and different-length strings)
	$(LI $(BUGZILLA 3386): to!bool(string) is not implemented)
	$(LI $(BUGZILLA 3436): std.functional.compose with only one function)
	$(LI $(BUGZILLA 3439): std.range.Sequence.opIndex not consistent after calling popFront().)
	$(LI $(BUGZILLA 3447): std.file uses unconventional file permissions)
	$(LI $(BUGZILLA 3528): FreeBSD patches for druntime.)
	$(LI $(BUGZILLA 3560): foreach over nested function generates wrong code)
	$(LI $(BUGZILLA 3569): DMD Stack Overflow with a struct member function inside a C-style struct initializer)
	$(LI $(BUGZILLA 3604): extern(C) callable function with array parameters broken)
	$(LI $(BUGZILLA 3679): Regression(2.031) template forward reference regression)
	$(LI $(BUGZILLA 3706): delegates of interfaces with multiple inheritance fail)
	$(LI $(BUGZILLA 3716): Regression (2.037) with multi dimensional array literals)
	$(LI $(BUGZILLA 3782): The POSIX sys/un.h header)
	$(LI $(BUGZILLA 3853): core.sys.posix.stdio.pclose is missing)
	$(LI $(BUGZILLA 3872): std.algorithm.filter could become bidirectional if its input range is bidir)
	$(LI $(BUGZILLA 3874): std.range.stride assumes a bidirectional input range)
	$(LI $(BUGZILLA 3917): opEquals for Ojbect could be more efficient)
	$(LI $(BUGZILLA 3937): os.path.dirname fails on absolute path)
	$(LI $(BUGZILLA 3961): Error with to!(somestruct))
	$(LI $(BUGZILLA 3983): Regression(2.037): struct with == can't be member of struct with template opEquals)
	$(LI $(BUGZILLA 4109): (reopened) writeln doesn't work with empty static array)
	$(LI $(BUGZILLA 4171): std.random.uniform does not work for a range of characters)
	$(LI $(BUGZILLA 4191): [FreeBSD] real constants are rounded to double precision)
	$(LI $(BUGZILLA 4198): [FreeBSD] imprecision in decimal floating-point literals)
	$(LI $(BUGZILLA 4238): Segfault(statement.c): with(typeof(int)))
	$(LI $(BUGZILLA 4260): windows & basename)
	$(LI $(BUGZILLA 4267): forward reference error when 2-fold aliasing a template instance)
	$(LI $(BUGZILLA 4303): __traits(compiles) returns wrong result when used recursively)
	$(LI $(BUGZILLA 4305): Take, Chain on top of ranges w/o moveFront() )
	$(LI $(BUGZILLA 4307): spawn()'ed thread doesn't terminate)
	$(LI $(BUGZILLA 4314): Regression(1.062): Expression array1 && array2 doesn't compile)
	$(LI $(BUGZILLA 4327): std.container.Array.Range.~this() tries to call free(T[]))
	$(LI $(BUGZILLA 4339): Struct destructor + invariant + struct parameter = horrific error message)
	$(LI $(BUGZILLA 4356): Copy constructor not called under extremely mysterious circumstances)
	$(LI $(BUGZILLA 4362): std.range.repeat and cycle do not have a .save() method)
	$(LI $(BUGZILLA 4363): std.algorithm.Until is not a forward range)
	$(LI $(BUGZILLA 4369): Multiple bugs in GC minimize())
	$(LI $(BUGZILLA 4370): POSIX monitor attribute not being used)
	$(LI $(BUGZILLA 4396): mkdir race prevents concurrent compiling with DMD using make -j)
	$(LI $(BUGZILLA 4400): D2 GC doesn't allocate with 16 bytes alignment)
	$(LI $(BUGZILLA 4406): Typo (bug) in std.concurrency)
	$(LI $(BUGZILLA 4412): Array capacity growth spikey and the ratio approaches 1.0)
	$(LI $(BUGZILLA 4443): Optimizer produces wrong code for || or && with struct arrays)
	$(LI $(BUGZILLA 4452): Incorrect result of BigInt ^^ long)
	$(LI $(BUGZILLA 4470): Problems with std.bigint mod and divide)
	$(LI $(BUGZILLA 4503): forward reference to aliased template instance)
	$(LI $(BUGZILLA 4506): Regression(2.034): -O flag breaks some recursive functions)
	$(LI $(BUGZILLA 4514): Regression: Cannot cast from X* to X)
	$(LI $(BUGZILLA 4516): Regression(2.040): forward declaration of enum not supported)
	$(LI $(BUGZILLA 4551): D2 Language Docs: http://www.digitalmars.com/d/2.0/arrays.html)
	$(LI $(BUGZILLA 4569): extern(c++) doesn't understand const types, produces bad mangled symbol)
	$(LI $(BUGZILLA 4570): ElementType!(void[]) shows error message)
	$(LI $(BUGZILLA 4578): Regression(2.047,1.062): ICE(cgcod.c): var+arr[])
	$(LI $(BUGZILLA 4590): Spec incorrectly describes array appending and memory stomping)
    )
)

$(VERSION 047, Jun 11, 2010, =================================================,

    $(WHATSNEW
	$(LI Changed "op=" to just "op" for template argument to opOpAssign)
	$(LI std.algorithm: Added save() to forward ranges; added split() using only one element as separator; added indexOf; fixed unlisted bug in startsWith and endsWith; added skipOver(); added canFind().)
	$(LI std.array: Added implementation of save() for T[]s.)
	$(LI std.concurrency: Eliminated spurious unittest stdout messages.)
	$(LI std.container: Added.)
	$(LI std.conv: Added file and line information to conversion errors; added brackets '[' and ']' around arrays and associative arrays as defaults; added emplace() for non-class types.)
	$(LI std.file: Replaced exception upon out-of-memory error with assert(0).)
	$(LI std.functional: toDelegate now accepts callable(function pointers, delegates and objects implement opCall) )
	$(LI std.path: Made basename() generic in string type.)
	$(LI std.range: Added the existence of the property save as a condition for isForwardRange; added save to the range defined within; replaced a couple of awkward front() implementations; defined module-level moveFront() and range member moveFront() where appropriate; added @property maxLength to Take; arranged things such that take() for slice-able ranges returns the same type as the slice; eliminated SListRange; defined iota() with one argument; moved BinaryHeap within.)
	$(LI std.regex: Qualified indexOf with std.algorithm.)
	$(LI std.regexp: Qualified indexOf with std.algorithm.)
	$(LI std.stdio: Added an error message to enforce() in rawRead().)
	$(LI std.string: Improved indexOf(), tolower(), splitter(), chomp().)
	$(LI std.traits: Added templates to get compile-time information about functions.)
	$(LI std.typecons: Added AutoImplement.)
	$(LI std.utf: Eliminated decodeFront() and decodeBack() - they aren't needed since strings are bidirectional ranges.)
	$(LI $(BUGZILLA 2008): Poor optimization of functions with ref parameters)
	$(LI $(BUGZILLA 3793): Functions with static arrays as arguments are not inlined)
	$(LI $(BUGZILLA 4296): Reduce parasitic error messages)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1193): regression: "matches more than one template declaration" doesn't list the location of the conflicting templates)
	$(LI $(BUGZILLA 1894): scope(exit) is ignored except in compound statements)
	$(LI $(BUGZILLA 1941): missing line on inaccesable external private module member)
	$(LI $(BUGZILLA 2127): inliner turns struct "return *this" from by-value into by-ref)
	$(LI $(BUGZILLA 2276): Error message missing line number on array operation)
	$(LI $(BUGZILLA 2546): Array Ops silently fail when no slice symbol is used.)
	$(LI $(BUGZILLA 2738): Rebindable should work for interfaces.)
	$(LI $(BUGZILLA 2835): std.socket.TcpSocket doesn't actually connect)
	$(LI $(BUGZILLA 2881): x.stringof returns typeof(x).stringof when x is an enum)
	$(LI $(BUGZILLA 3064): Invalid array operation accepted, generates bad code)
	$(LI $(BUGZILLA 3088): std.xml.check() fails on xml comments)
	$(LI $(BUGZILLA 3139): compiler dies "Error: out of memory" with case range)
	$(LI $(BUGZILLA 3200): std.xml doesn't follow spec for Tag.text)
	$(LI $(BUGZILLA 3323): Segfault or ICE(e2ir.c) using struct with destructor almost anywhere)
	$(LI $(BUGZILLA 3398): Attributes inside a union screws data alignment)
	$(LI $(BUGZILLA 3465): isIdeographic can be wrong in std.xml)
	$(LI Major improvements to CustomFloat, fixing $(BUGZILLA 3520):  std.numeric.CustomFloat horribly broken)
	$(LI $(BUGZILLA 3538): Default value of alias template parameter is instantiated only once.)
	$(LI $(BUGZILLA 3547): for option -od for relative path the path is added twice)
	$(LI $(BUGZILLA 3548): ICE occurs when an array is returned from a function is incorrectly used in an array op expression.)
	$(LI $(BUGZILLA 3604): extern(C) callable function with array parameters broken)
	$(LI $(BUGZILLA 3651): mangleof broken for enums)
	$(LI $(BUGZILLA 3653): Problem sorting array of Rebindable)
	$(LI $(BUGZILLA 3658): Crashing on vector operations (Mac only))
	$(LI $(BUGZILLA 3662): Wrong compile error within struct constructor and C-style initializer)
	$(LI $(BUGZILLA 3667): Regression(D2 only): broken out(result) in contracts)
	$(LI $(BUGZILLA 3786): bug in std.string.removechars)
	$(LI $(BUGZILLA 3854): Error on static initialization of arrays with trailing comma.)
	$(LI $(BUGZILLA 3873): std.range.repeat should have popBack defined)
	$(LI $(BUGZILLA 3876): std.range.Take back/popBack methods don't work correctly)
	$(LI $(BUGZILLA 3880): std.regex functions with const/immutable Regex object)
	$(LI $(BUGZILLA 4003): The result changes only with the order of source files.)
	$(LI $(BUGZILLA 4045): [CTFE] increasing array length)
	$(LI $(BUGZILLA 4052): [CTFE] increment from array item)
	$(LI $(BUGZILLA 4056): Template instantiation with bare parameter not documented)
	$(LI $(BUGZILLA 4073): core.cpuid crashes)
	$(LI $(BUGZILLA 4078): [CTFE] Failed return of dynamic array item)
	$(LI $(BUGZILLA 4084): Ignored missing main() closing bracket)
	$(LI $(BUGZILLA 4109): writeln doesn't work with empty static array)
	$(LI $(BUGZILLA 4143): fix warnings in dmd build)
	$(LI $(BUGZILLA 4156): Segfault with array+=array)
	$(LI $(BUGZILLA 4169): building dmd with a modern gcc produces a buggy compiler)
	$(LI $(BUGZILLA 4175): linux.mak doesn't declare sufficient dependencies to support parallel builds)
	$(LI $(BUGZILLA 4188): std.file.remove throws Exception on success)
	$(LI $(BUGZILLA 4193): Regression 2.046, ICE(expression.c): initialising class member with const forward reference)
	$(LI $(BUGZILLA 4202): Changset 1517 doesn't compile)
	$(LI $(BUGZILLA 4207): std.cover.setDestDir does not work.)
	$(LI $(BUGZILLA 4208): druntime should not depend on Phobos)
	$(LI $(BUGZILLA 4212): DWARF: void arrays cause gdb errors)
	$(LI $(BUGZILLA 4213): Strange behaviour with static void[] arrays)
	$(LI $(BUGZILLA 4219): hasAliasing does not care about immutable)
	$(LI $(BUGZILLA 4220): I cannot apply @safe to intrinsic operation(eg: std.math.sqrt))
	$(LI $(BUGZILLA 4228): std.array.replace contains 2 bugs)
	$(LI $(BUGZILLA 4230): version(unittest))
	$(LI $(BUGZILLA 4231): Solitary opUnary Postincrement and Postdecrement user defined operators are broken.)
	$(LI $(BUGZILLA 4242): ICE(module.c): importing a module with same name as package)
	$(LI $(BUGZILLA 4249): std.regex fails to compile with debug=regex)
	$(LI $(BUGZILLA 4252): [CTFE] No array bounds checking in assignment to char[] array)
	$(LI $(BUGZILLA 4257): ICE(interpret.c): passing parameter into CTFE as ref parameter)
	$(LI $(BUGZILLA 4259): Header generation omits leading '@' for properties)
	$(LI $(BUGZILLA 4262): Header generation omits 'enum' for enum declarations)
	$(LI $(BUGZILLA 4263): Header generation omits '@system' attribute)
	$(LI $(BUGZILLA 4270): Missing line number in 'can only catch class objects' error message)
	$(LI $(BUGZILLA 4300): BigInt * int doesn't work well)
    )
)

$(VERSION 046, May 10, 2010, =================================================,

    $(WHATSNEW
	$(LI Add hints for missing import declarations.)
	$(LI Speed up compilation.)
	$(LI All length methods in Phobos are now a @property.)
	$(LI $(BUGZILLA 1001): print stack trace (in debug mode) when program die)
    )
    $(BUGSFIXED
	$(LI Fix hanging problem on undefined identifiers.)
	$(LI $(BUGZILLA 461): Constant not understood to be constant when circular module dependency exists.)
	$(LI $(BUGZILLA 945): template forward reference with named nested struct only)
	$(LI $(BUGZILLA 1055): union forward reference "overlapping initialization" error)
	$(LI $(BUGZILLA 2085): CTFE fails if the function is forward referenced)
	$(LI $(BUGZILLA 2386): Array of forward referenced struct doesn't compile)
	$(LI $(BUGZILLA 3945): AssertExpression message should implicitly convert to const char[])
	$(LI $(BUGZILLA 4015): forward reference in alias causes error)
	$(LI $(BUGZILLA 4016): const initializer cannot forward reference other const initializer)
	$(LI $(BUGZILLA 4042): Unable to instantiate a struct template.)
	$(LI $(BUGZILLA 4100): Break and continue to label should mention foreach)
	$(LI $(BUGZILLA 4116): object.di does not match object_.d)
	$(LI $(BUGZILLA 4146): Unavailable: core.sys.posix.sys.wait.waitid())
	$(LI $(BUGZILLA 4184): associative array with certain key types results in corrupt values during iteration)
    )
)

$(VERSION 045, May 4, 2010, =================================================,

    $(WHATSNEW
    )
    $(BUGSFIXED
	$(LI Another try at fixing the Dwarf issues.)
    )
)

$(VERSION 044, Apr 30, 2010, =================================================,

    $(WHATSNEW
	$(LI Improve spelling checking distance to 2.)
	$(LI Now all unittests are run, even if some fail)
	$(LI Many small improvements to error diagnostics and recovery)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1079): gdb: Dwarf Error: Cannot find DIE at 0xb705 referenced from DIE at 0x250)
	$(LI $(BUGZILLA 2437): ICE(tocsym.c, !needThis()) - default struct argument)
	$(LI $(BUGZILLA 2935): ICE(out.c) using struct with constructor as function default argument)
	$(LI $(BUGZILLA 2549): Segfault on array multiplication.)
	$(LI $(BUGZILLA 3066): Array operation without a slice as the lvalue accepted, bad codegen)
	$(LI $(BUGZILLA 3207): gdb: Push D patches upstream)
	$(LI $(BUGZILLA 3415): broken JSON output)
	$(LI $(BUGZILLA 3522): ICE(cg87.c): variable*array[].)
	$(LI $(BUGZILLA 3987): [gdb] Invalid DWARF output for function pointers)
	$(LI $(BUGZILLA 3974): ICE(init.c): Static array initializer with more elements than destination array)
	$(LI $(BUGZILLA 4036): Segfault with -inline and literal of struct containing union)
	$(LI $(BUGZILLA 4037): [gdb] Invalid DWARF output for wchar)
	$(LI $(BUGZILLA 4038): [gdb] Invalid DWARF output for function pointers with ref args)
	$(LI $(BUGZILLA 4067): [CTFE] Code inside try-catch blocks is silently ignored)
	$(LI $(BUGZILLA 4072): Stack overflow on recursive template expansion inside contract)
	$(LI $(BUGZILLA 4081): cannot compile the dmd on FreeBSD 8)
	$(LI $(BUGZILLA 4089): crash when creating JSON output for incomplete struct)
	$(LI $(BUGZILLA 4093): Segfault(interpret.c): with recursive struct templates)
	$(LI $(BUGZILLA 4105): Stack overflow involving alias template parameters and undefined identifier)
	$(LI $(BUGZILLA 4108): ICE(cod2.c): zero-length static array in function call)
	$(LI $(BUGZILLA 4118): std.conv.to!SomeStruct("hello") crashes compiler)
	$(LI $(BUGZILLA 4131): break does not work correctly with foreach and associative arrays)
    )
)

$(VERSION 043, Apr 6, 2010, =================================================,

    $(WHATSNEW
	$(LI $(B .init) property for static arrays is now an array literal)
	$(LI Improved speed of associative arrays)
	$(LI std.bigint has been completely replaced with a faster implementation.
	   Multiplication is now 5 times faster, division is
	   300 times faster, and squaring is 10 times faster. For large numbers
	   (~5000 words), the speedup is 5 times larger than this.)
    )
    $(BUGSFIXED
	$(LI Fixed memory corruption problem with array appends)
	$(LI $(BUGZILLA 122): DDoc newline behaviour produces suboptimal results)
	$(LI $(BUGZILLA 1628): Ddoc produces invalid documentation for --- blocks)
	$(LI $(BUGZILLA 2609): No documentation generated for destructor)
	$(LI $(BUGZILLA 3808): Assertion Failure : Assertion failure: 'classinfo->structsize == CLASSINFO_SIZE' on line 870 in file 'toobj.c')
	$(LI $(BUGZILLA 3884): Segfault: defining a typedef with an invalid object.d)
	$(LI $(BUGZILLA 3911): Associative array in CTFE crashes compiler)
	$(LI $(BUGZILLA 3958): mixin(non-static method) crashes compiler)
	$(LI $(BUGZILLA 3972): Regarding module with name different from its file name)
	$(LI $(BUGZILLA 3984): Segfault(interpret.c): CTFE using struct constructor on a local static variable)
	$(LI $(BUGZILLA 3986): Struct constructors bypass default initialization of member variables)
	$(LI $(BUGZILLA 4002): dmd.conf and binary path in dmd -v output)
	$(LI $(BUGZILLA 4004): DMD 2.042 CTFE regression with functions taking ref parameters)
	$(LI $(BUGZILLA 4005): std.c.stdlib.exit in CTFE and more)
	$(LI $(BUGZILLA 4011): Incorrect function overloading using mixins)
	$(LI $(BUGZILLA 4019): [CTFE] Adding an item to an empty AA)
	$(LI $(BUGZILLA 4020): [ICE][CTFE] struct postblit in CTFE)
	$(LI $(BUGZILLA 4023): std.math.hypot() returns infinity when either argument is zero)
	$(LI $(BUGZILLA 4027): Closures in CTFE generate wrong code)
	$(LI $(BUGZILLA 4029): CTFE: cannot invoke delegate returned from function)
    )
)

$(VERSION 042, Mar 19, 2010, =================================================,

    $(WHATSNEW
    )
    $(BUGSFIXED
	$(LI Add base class destruction to clear() in object.d)
	$(LI $(BUGZILLA 3842): ICE(expression.c) using pointer in CTFE)
	$(LI $(BUGZILLA 3885): No multithread support for Windows DLL)
	$(LI $(BUGZILLA 3899): CTFE: poor error message for use of uninitialized variable)
	$(LI $(BUGZILLA 3900): CTFE: Wrong return value for array.var assignment)
	$(LI $(BUGZILLA 3901): PATCH: Nested struct assignment for CTFE)
	$(LI $(BUGZILLA 3902): Definition of opCmp)
	$(LI $(BUGZILLA 3912): pure static nested functions are not recognized as pure)
	$(LI $(BUGZILLA 3914): Struct as argument that fits in register has member accessed wrong)
	$(LI $(BUGZILLA 3919): ICE(expression.c, 9944): * or / with typedef ireal)
	$(LI $(BUGZILLA 3920): Assertion failure: '0' on line 10018 in file 'expression.c')
	$(LI $(BUGZILLA 3930): AAs horribly broken)
    )
)

$(VERSION 041, Mar 7, 2010, =================================================,

    $(WHATSNEW
	$(LI __traits allMembers and and derivedMembers now return a tuple of strings
	 rather than an array of strings. Enclose __traits in [ ] to make array literal.
	 This makes it possible for foreach statements to iterate at compile time over it.
	)
	$(LI Interface member functions can now have $(LINK2 interface.html#InterfaceContracts, contracts).)
	$(LI Added new $(LINK2 operatoroverloading.html, operator overloading) regime.)
	$(LI Warnings no longer halt the parsing/semantic passes, though they still return
	 an error status and still do not generate output files. They also no longer count
	 as errors when testing with "compiles" traits.)
	$(LI Added $(B -wi) switch for $(BUGZILLA 2567))
	$(LI Mixin template definitions should be preceded with $(CODE mixin))
	$(LI Add $(LINK2 expression.html#InExpression, $(B !in)) operator.)
	$(LI Associative array contents can now be compared for equality)
	$(LI Use of $(B length) inside of [ ] is now deprecated, use $(DOLLAR) instead)
	$(LI Added $(B toDelegate()) to std.functional to convert function pointers to delegates.)
	$(LI Implemented attributes for constructors.)
	$(LI Implemented qualifiers for struct literals, like $(CODE immutable(S)(1,2,3)))
	$(LI Array equality can now be done with differing array element types.)
	$(LI Add simple spell checking.)
	$(LI $(BUGZILLA 3378): [tdpl] ++x should be an lvalue)
	$(LI string, wstring are now bidirectional (not random) ranges)
	$(LI std.algorithm: defined move with one argument; levenshtein distance generalized to with all forward ranges; take now has swapped arguments)
	$(LI std.array: empty for arrays is now a @property; front and back for a string and wstring automatically decodes the first/last character; popFront, popBack for string and wstring obey the UTF stride)
	$(LI std.conv: changed the default array formatting from "[a, b, c]" to "a b c")
	$(LI std.range: swapped order of arguments in take)
	$(LI std.stdio: added readln template)
	$(LI std.variant: now works with statically-sized arrays and const data)
	$(LI std.traits: added isNarrowString)
	$(LI The default type for [1,2,3] is now int[] rather than int[3].)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 2321): spec on inline asm can be misunderstood)
	$(LI $(BUGZILLA 2463): No line number in "statement is not reachable" warning)
	$(LI $(BUGZILLA 3029): Bug in array value mangling rule)
	$(LI $(BUGZILLA 3306): bad function/delegate literal generated into header files)
	$(LI $(BUGZILLA 3373): bad codeview debug info for long and ulong)
	$(LI Posix only, $(BUGZILLA 3420): [PATCH] Allow string import of files using subdirectories)
	$(LI $(BUGZILLA 3450): incorrect result for is (typeof({ ... }())) inside a struct)
	$(LI $(BUGZILLA 3453): Linking order affects proper execution (Mac OSX only))
	$(LI $(BUGZILLA 3491): typeof((string[string]).init) == AssociativeArray!(string, string), doesn't implicitly convert to string[string].)
	$(LI $(BUGZILLA 3500): super behaves differently with -inline)
	$(LI $(BUGZILLA 3558): Optimizer bug results in false if condition being taken)
	$(LI $(BUGZILLA 3582): core.stdc.ctype functions are not pure)
	$(LI $(BUGZILLA 3619): Thread crash on exit)
	$(LI $(BUGZILLA 3637): Array append patch to prevent stomping and to enhance thread-local append performance)
	$(LI $(BUGZILLA 3644): Wrong UCHAR_MAX value in module core.stdc.limits)
	$(LI $(BUGZILLA 3670): Declarator grammar rule is broken)
	$(LI $(BUGZILLA 3689): Grammar does not allow const(int))
	$(LI $(BUGZILLA 3692): ICE(mtype.c) with associative arrays when std.variant is imported)
	$(LI $(BUGZILLA 3695): __EOF__ token not documented)
	$(LI $(BUGZILLA 3697): StructTemplateDeclaration and others missing constraint in rule)
	$(LI $(BUGZILLA 3710): Typo in allMembers description?)
	$(LI $(BUGZILLA 3736): corrupted struct returned by function with optimizations (-O))
	$(LI $(BUGZILLA 3737): SEG-V at expression.c:6255 from bad opDispatch)
	$(LI $(BUGZILLA 3763): std.stdio.readlnImpl absurdly inefficient and overflows stack)
	$(LI $(BUGZILLA 3768): reapeted quotes in ddoc.html)
	$(LI $(BUGZILLA 3769): Regression: Segfault(constfold.c) array literals and case statements)
	$(LI $(BUGZILLA 3775): Segfault(cast.c): casting no-parameter template function using property syntax)
	$(LI $(BUGZILLA 3776): Wrong CHAR_MIN value in module core.stdc.limits)
	$(LI $(BUGZILLA 3781): ICE(interpret.c): using no-argument C-style variadic function in CTFE)
	$(LI $(BUGZILLA 3803): compiler segfaults)
	$(LI $(BUGZILLA 3840): Jump to: section in the docs should be sorted)
    )
)

$(VERSION 040, Jan 29, 2010, =================================================,

    $(WHATSNEW
	$(LI Clarification: function returns are not lvalues)
	$(LI Added shared static constructors/destructors, regular static
	constructors/destructors now deal with TLS)
	$(LI Add $(B -map) command line switch)
	$(LI Add $(LINK2 attribute.html#disable, $(B @disable)) attribute)
	$(LI Delegates and function pointers may be used in CTFE)
	$(LI Delegate literals and function literals may be used in CTFE)
	$(LI Lazy function parameters may now be used in CTFE)
	$(LI Slicing of char[] arrays may now be used in CTFE)
	$(LI added static/final function implementations to interfaces)
	$(LI added $(B getOverloads), $(B identifier), and $(B isStaticFunction) traits.)
	$(LI ModuleInfo changed from class to struct)
	$(LI $(BUGZILLA 3556): version(CTFE))
	$(LI $(BUGZILLA 3728): getOverloads and identifier traits)
    )
    $(BUGSFIXED
	$(LI Added TLS support for OSX)
	$(LI $(CPPBUGZILLA 47): Internal error: cg87 3316)
	$(LI $(BUGZILLA 1298): CTFE: tuple foreach bugs)
	$(LI $(BUGZILLA 1790): CTFE: foreach(Tuple) won't compile if Tuple contains string)
	$(LI $(BUGZILLA 2101): CTFE: Please may I use mutable arrays at compile time?)
	$(LI $(BUGZILLA 2066): to!(string)(int) into CTFE-compatible)
	$(LI $(BUGZILLA 3488): Segfault(expression.c): enum declared with struct static initializer)
	$(LI $(BUGZILLA 3535): struct constructors don't work in CTFE)
	$(LI $(BUGZILLA 3552): ICE(mtype.c): declaring a variable called 'AssociativeArray' then using an AA.)
	$(LI Partial fix for $(BUGZILLA 3569), stops the stack overflow)
	$(LI $(BUGZILLA 3600): template instantiation with empty tuple)
	$(LI $(BUGZILLA 3660): Templates and shared functions don't mix)
	$(LI $(BUGZILLA 3668): foreach over typedef'd array crashes dmd)
	$(LI $(BUGZILLA 3671): x^^3 gives wrong result when x is a floating-point literal)
	$(LI $(BUGZILLA 3674): forward reference error with multiple overloads with same name)
	$(LI $(BUGZILLA 3675): Regression: Struct literals cannot be initialized with another struct literal)
	$(LI $(BUGZILLA 3687): Array operation "slice times scalar" tramples over memory)
	$(LI $(BUGZILLA 3719): forward references can cause out-of-memory error)
	$(LI $(BUGZILLA 3723): Regression: forward referenced enum)
	$(LI $(BUGZILLA 3724): bug in Expression::arraySyntaxCopy (null pointer dereference on struct->union->struct))
	$(LI $(BUGZILLA 3726): Regression: ICE(mangle.c 81): struct forward reference with static this)
	$(LI $(BUGZILLA 3727): lots of "deffering SomeStructName" messages when compiling)
	$(LI $(BUGZILLA 3734): [patch] src/traits.c does not compile with gcc (Ubuntu 4.4.1-4ubuntu8) 4.4.1)
	$(LI $(BUGZILLA 3740): Regression: class with fwd reference of a nested struct breaks abstract)
    )
)

$(VERSION 039, Jan 1, 2010, =================================================,

    $(WHATSNEW
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 3663): struct forward reference regresssion)
	$(LI $(BUGZILLA 3664): struct forward declaration causes enum to conflict with itself)
    )
)

$(VERSION 038, Dec 30, 2009, =================================================,

    $(WHATSNEW
	$(LI Added core.cpuid in Druntime)
	$(LI $(BUGZILLA 3514): opApply should be the first-choice foreach iteration method.)
	$(LI $(BUGZILLA 3577): Wrong precedence for opPow)
	$(LI Added $(LINK2 function.html#auto-ref-functions, auto ref functions))
	$(LI Added $(LINK2 template.html#auto-ref-parameters, function template auto ref parameters))
	$(LI Added $(B isRef), $(B isOut) and $(B isLazy) to $(LINK2 traits.html, $(D_KEYWORD __traits)))
	$(LI Transporting return type from args to return type, see $(LINK2 http://www.prowiki.org/wiki4d/wiki.cgi?LanguageDevel/DIPs/DIP2, DIP2))
    )
    $(BUGSFIXED
	$(LI $(CPPBUGZILLA 45): Internal error: cgcod 1594)
	$(LI $(CPPBUGZILLA 46): Constant folding with long doubles)
	$(LI $(BUGZILLA 282): Bizarre circular import nested name invisibility issue)
	$(LI $(BUGZILLA 390): Cannot forward reference enum nested in struct)
	$(LI $(BUGZILLA 400): forward reference error; no propety X for type Y (struct within struct))
	$(LI $(BUGZILLA 1160): enums can not be forward referenced)
	$(LI $(BUGZILLA 1564): Forward reference error for enum in circular import)
	$(LI $(BUGZILLA 2029): Typesafe variadic functions don't work in CTFE)
	$(LI $(BUGZILLA 2816): Sudden-death static assert is not very useful)
	$(LI $(BUGZILLA 3270): pure functions returning struct)
	$(LI $(BUGZILLA 3443): Thread.thread_needLock() should be nothrow)
	$(LI $(BUGZILLA 3455): Some Unicode characters not allowed in identifiers)
	$(LI $(BUGZILLA 3458): int fsync(int) commented out in core.sys.posix.unistd)
	$(LI $(BUGZILLA 3476): C-style initializer for structs must be disallowed for structs with a constructor)
	$(LI $(BUGZILLA 3575): CTFE: member structs not initialized correctly)
	$(LI $(BUGZILLA 3583): Unsigned right shift works the same as signed right shift.)
	$(LI $(BUGZILLA 3584): DeclDef rule is missing entries)
	$(LI $(BUGZILLA 3585): Duplicate clauses in EqualExpression and RelExpression rules)
	$(LI $(BUGZILLA 3587): Aggregate rule references undefined Tuple)
	$(LI $(BUGZILLA 3588): WithStatement rule references unspecified Symbol)
	$(LI $(BUGZILLA 3589): BaseClassList and InterfaceClasses rules are incorrect, missing ',')
	$(LI $(BUGZILLA 3590): FunctionParameterList rule is missing)
	$(LI $(BUGZILLA 3591): TemplateIdentifier rule is misspelled)
	$(LI $(BUGZILLA 3592): ClassTemplateDeclaration and FunctionTemplateDeclaration rules are unreferenced)
	$(LI $(BUGZILLA 3593): IntegerExpression rule unspecified)
	$(LI $(BUGZILLA 3594): AsmPrimaryExp rule references unspecified rules)
	$(LI $(BUGZILLA 3595): Several rules are missing ':' after rule name)
	$(LI $(BUGZILLA 3596): Need alias for using std.algorithm.remove)
	$(LI $(BUGZILLA 3601): Debug and Release builds of DMD produce different object files)
	$(LI $(BUGZILLA 3611): Enum forward referencing regression)
	$(LI $(BUGZILLA 3612): ExpressionList is undefined)
	$(LI $(BUGZILLA 3617): CTFE: wrong code for if(x) where x is int or smaller)
	$(LI $(BUGZILLA 3621): implicit conversion to const rules need tightening)
	$(LI $(BUGZILLA 3633): Optimizer causes access violation)
	$(LI $(BUGZILLA 3641): alias shared T U does not work)
	$(LI $(BUGZILLA 3645): manifest constant (enum) crashes dmd)
	$(LI $(BUGZILLA 3647): non-function opDispatch crashes dmd)
    )
)

$(VERSION 037, Dec 3, 2009, =================================================,

    $(WHATSNEW
	$(LI Conditional expressions ?: can now be modifiable lvalues.)
	$(LI The type inferred from an
	 $(LINK2 expression.html#ArrayLiteral, $(I ArrayLiteral))
	 is now a dynamic array, not a static one.)
	$(LI Added support for $(I op)= for array.length)
	$(LI Array and associative array types are now determined by using ?: across
	 all the elements, not just using the first one.)
	$(LI Array concatenation with elements now allows implicit conversion of
	 the elements to the array element type.)
	$(LI No more comma operators allowed between [ ].)
	$(LI ClassInfo now merged into TypeInfo_Class.)
	$(LI $(BUGZILLA 3379): [tdpl] Parameter names not visible in the if clause of a template)
	$(LI $(BUGZILLA 3380): [tdpl] typeid(obj) should return the dynamic type of the object)
	$(LI Removed $(B -safe) command line switch, added $(B -noboundscheck) command
	 line switch.)
	$(LI $(BUGZILLA 3481): PATCH: opPow(), x ^^ y as a power operator)
	$(LI Added opDispatch)
	$(LI properties can only have 0 or 1 arguments)
	$(LI properties cannot be overloaded with non-properties)
	$(LI std.math: Added FloatControl, IeeeFlags for enabling floating-point exceptions.)
	$(LI std.math: Inverse trig functions are now pure nothrow.)
    )
    $(BUGSFIXED
	$(LI std.array: Fixed unlisted bug in array().)
	$(LI $(BUGZILLA 111): appending a dchar to a char[])
	$(LI $(BUGZILLA 2664): OSX standard math functions are less accurate)
	$(LI $(BUGZILLA 2802): VariantN.opCmp!(T) fails when T != VariantN)
	$(LI $(BUGZILLA 2967): spec does not mention that inline asm is a valid "return" statement)
	$(LI $(BUGZILLA 2977): std.random.unpredictableSeed() should use thread ID somewhere)
	$(LI $(BUGZILLA 3115): &gt;&gt;&gt; and &gt;&gt;&gt;= generate wrong code)
	$(LI $(BUGZILLA 3171): % not implemented correctly for floats)
	$(LI $(BUGZILLA 3311): std.range.chain shouldn't have opIndexAssign if arguments aren't mutable)
	$(LI $(BUGZILLA 3375): [tdpl] Ternary operator doesn't yield an lvalue)
	$(LI $(BUGZILLA 3381): [tdpl] Incorrect assessment of overriding in triangular-shaped hierarchy)
	$(LI $(BUGZILLA 3388): [tdpl] contracts should allow throw expressions)
	$(LI $(BUGZILLA 3390): [tdpl] out(result) contract should not be able to rebind result)
	$(LI $(BUGZILLA 3407): [tdpl] Compiling with -safe -release must keep all bound checks)
	$(LI $(BUGZILLA 3433): [tdpl] Comparing structs for equality is not member-by-member)
	$(LI $(BUGZILLA 3469): ICE(func.c): Regression. Calling non-template function as a template, from another module)
	$(LI $(BUGZILLA 3478): "no effect in expression" error on return to void)
	$(LI $(BUGZILLA 3494): Segfault(mtype.c) using typeof(return) inside an auto function)
	$(LI $(BUGZILLA 3495): Segfault(typinf.c) instantiating D variadic function with too few arguments)
	$(LI $(BUGZILLA 3496): ICE(cgelem.c, optimizer bug) cast(void *)(x&1)== null.)
	$(LI $(BUGZILLA 3502): Fix for dropped Mac OS X 10.5)
	$(LI $(BUGZILLA 3521): Optimized code access popped register)
	$(LI $(BUGZILLA 3540): Another DWARF line number fix)
	$(LI $(BUGZILLA 3551): nested struct => dmd adds a hidden pointer)
	$(LI $(BUGZILLA 3553): ICE when a function argument defaults to __LINE__)
    )
)

$(VERSION 036, Nov 5, 2009, =================================================,

    $(WHATSNEW
	$(LI Static arrays are now passed by value to functions rather than by reference)
	$(LI   std.algorithm:  Add   hasLength   requirement  to   topN;
	implemented  topN for  two non-adjacent  ranges;  added replaceTop
	function to BinaryHeap; changed BinaryHeap.top to return ref.)
	$(LI std.ctype:  Add pure  to isalnum, isalpha,  iscntrl, isdigit,
	islower,  ispunct, isspace,  isxdigit, isgraph,  isprint, isascii,
	toupper.)
	$(LI std.date: Implementation change and unittest for isLeapYear and
	daysInYear. Made both pure as well.)
	$(LI std.encoding: Added function count().)
	$(LI std.md5: Added explicit pass-by-ref for fixed-size buffers.)
	$(LI std.numeric: Added gcd.)
	$(LI std.random: Added static checks for the parameters of the linear
	congruential generator.)
	$(LI std.range: Reinstated some unittests; fixed Cycle to work with
	the new fixed-size arrays.)
	$(LI std.typecons: Added alias 'expand' for Tuple.field.)
	$(LI std:utf: Added count function and changed the encode function
	to take fixed-size array by reference.)
	$(LI $(BUGZILLA 3446): Rename float.min to float.min_normal)
    )
    $(BUGSFIXED
	$(LI std.range: Fixed unlisted bug in Transposed.)
	$(LI Problem with complicated array op expressions)
	$(LI $(BUGZILLA 195): DDoc generates bad output when example contains "protected" attribute)
	$(LI $(BUGZILLA 424): Unexpected OPTLINK Termination at EIP=0044C37B (too many fixups))
	$(LI $(BUGZILLA 1117): ddoc generates corrupted docs if code examples contain attributes with colons)
	$(LI $(BUGZILLA 1812): DDOC - Unicode identifiers are not correctly marked.)
	$(LI $(BUGZILLA 2694): alias pure nothrow XXX; is not pure nothrow!)
	$(LI $(BUGZILLA 2862): ICE(template.c) using type tuple as function argument)
	$(LI $(BUGZILLA 3035): cannot have const/invariant out parameter of type shared)
	$(LI $(BUGZILLA 3102): Incorrectly matching type as shared (two cases with is expressions))
	$(LI $(BUGZILLA 3269): pure functions silently become nothrow)
	$(LI $(BUGZILLA 3292): ICE(todt.c) when using a named mixin with an initializer as template alias parameter)
	$(LI $(BUGZILLA 3349): typeid(shared(T)) generates wrong value)
	$(LI $(BUGZILLA 3367): Regression: struct initialization no longer supports ctor overloads)
	$(LI $(BUGZILLA 3397): Unintended function call to static opCall)
	$(LI $(BUGZILLA 3401): Compiler crash on invariant + method overload)
	$(LI $(BUGZILLA 3422): ICE(cgcod.c) Structs with default initializers bigger than register size cannot be default parameters)
	$(LI $(BUGZILLA 3423): Destructor and postblit don't get copied to the header file when using -H)
	$(LI $(BUGZILLA 3426): ICE(optimize.c): struct literal with cast, as function default parameter.)
	$(LI $(BUGZILLA 3429): Core dump on passing template literal to member function.)
	$(LI $(BUGZILLA 3432): ICE(e2ir.c): casting template expression)
    )
)

$(VERSION 035, Oct 14, 2009, =================================================,

    $(WHATSNEW
	$(LI Use $(B -X) to generate JSON files.)
    )
    $(BUGSFIXED
	$(LI Fold in patch from $(BUGZILLA 1170))
	$(LI $(BUGZILLA 1534): Can't mix in a case statement.)
	$(LI $(BUGZILLA 2423): Erroneous unreachable statement warning)
	$(LI $(BUGZILLA 2826): failed assignment gives wrong line number)
	$(LI $(BUGZILLA 3190): enum doesn't work as the increment in a for loop)
	$(LI $(BUGZILLA 3316): Functions nested in a pure templated function cannot reference its local variables)
	$(LI $(BUGZILLA 3352): RangeError in std.conv)
	$(LI $(BUGZILLA 3385): `std.string.split` requires a mutable array)
	$(LI $(BUGZILLA 3392): a cast of this to void in tango.core.Thread is not allowed)
    )
)

$(VERSION 034, Oct 11, 2009, =================================================,

    $(WHATSNEW
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 258): Undefined identifier error for circular import)
	$(LI $(BUGZILLA 1140): ICE(cod1.c) casting last function parameter to 8 byte value)
	$(LI $(BUGZILLA 1592): dmd fail to resolve class symbol when i put files in a package)
	$(LI $(BUGZILLA 2687): ICE(statement.c): tuple foreach in an erroneous template.)
	$(LI $(BUGZILLA 2773): ICE(go.c) array assignment through a pointer, only with -O.)
	$(LI $(BUGZILLA 2829): ICE(expression.c) static array block-initialized in struct literal)
	$(LI $(BUGZILLA 3006): ICE(e2ir.c, tocsym.c) template module using array operation)
	$(LI $(BUGZILLA 3041): Array slices can be compared to their element type: bad codegen or ICE)
	$(LI $(BUGZILLA 3042): Segfault on incorrect override)
	$(LI $(BUGZILLA 3101): Stack overflow: declaring aggregate member twice with static if)
	$(LI $(BUGZILLA 3119): Segfault(expression.c) template function overloads with function with same name in other module)
	$(LI $(BUGZILLA 3174): ICE(mtype.c): Compiler crash or compiler error with auto returns and const / immutable / invarient / pure)
	$(LI $(BUGZILLA 3176): Compiler hangs on poorly formed mixin in variadic template)
	$(LI $(BUGZILLA 3261): compiler crash with mixin and forward reference)
	$(LI $(BUGZILLA 3286): Default parameter prevents to resolve inter-module circular dependency)
	$(LI $(BUGZILLA 3301): Undefined identifier error dependent on order of imports when a circular import is involved)
	$(LI $(BUGZILLA 3325): ICE(func.c) function literal with post-contract)
	$(LI $(BUGZILLA 3343): Crash by "auto main(){}")
	$(LI $(BUGZILLA 3344): ICE(e2ir.c) returning an invalid function from main())
	$(LI $(BUGZILLA 3357): ICE(cod1.c) using 'in' with a static char array as AA key)
	$(LI $(BUGZILLA 3366): Segfault(declaration.c) variadic template with unmatched constraint)
	$(LI $(BUGZILLA 3374): [tdpl] ICE(init.c): Associative array type not inferred)
    )
)

$(VERSION 033, Oct 5, 2009, =================================================,

    $(WHATSNEW
	$(LI Phobos is now using the Boost 1.0 license)
	$(LI Compiler now detects some cases of illegal null dereferencing when compiled with -O)
	$(LI The result type of the $(CODE typeid($(I type))) is now the most derived TypeInfo class, rather than the TypeInfo base class)
	$(LI $(BUGZILLA 2905): Faster +-*/ involving a floating-pointing literal)
	$(LI Improved performance of int-to-string conversion)
    )
    $(BUGSFIXED
	$(LI gdb stack trace should work now)
	$(LI $(BUGZILLA 302): in/out contract inheritance yet to be implemented)
	$(LI $(BUGZILLA 718): ICE(cgcod.c) with int /= cast(creal))
	$(LI $(BUGZILLA 814): lazy argument + variadic arguments = segfault)
	$(LI $(BUGZILLA 1168): Passing a .stringof of an expression as a template value parameter results in the string of the type)
	$(LI $(BUGZILLA 1253): array initializers as expressions are not allowed in const arrays)
	$(LI $(BUGZILLA 1571): Segfault(class.c) const on function parameters not carried through to .di file)
	$(LI $(BUGZILLA 1731): forward reference of function type alias resets calling convention)
	$(LI $(BUGZILLA 2202): Error getting type of non-static member of a class)
	$(LI $(BUGZILLA 2469): ICE(cod1.c) arbitrary struct accepted as struct initializer)
	$(LI $(BUGZILLA 2697): Cast of float function return to ulong or uint gives bogus value)
	$(LI $(BUGZILLA 2702): Struct initialisation silently inserts deadly casts)
	$(LI $(BUGZILLA 2839): ICE(cgcs.c) with int /= imaginary)
	$(LI $(BUGZILLA 2970): std.path.join with version(Windows))
	$(LI $(BUGZILLA 2998): ICE(expression.c) with floating point enum)
	$(LI $(BUGZILLA 3049): ICE(cod4.c) or segfault: Array operation on void[] array)
	$(LI $(BUGZILLA 3059): Nonsensical complex op= should be illegal)
	$(LI $(BUGZILLA 3132): std.string.split should be templated on mutable/const/immutable - closing again after the reopening on 2009-09-03 07:56:25 PDT)
	$(LI $(BUGZILLA 3160): ICE(cgcod.c 1511-D1) or bad code-D2 returning string from void main)
	$(LI $(BUGZILLA 3173): ICE(mtype.c) on wrong code (double to long to int conversion))
	$(LI $(BUGZILLA 3288): conv.d: using to with const int or long fails to compile.)
	$(LI $(BUGZILLA 3300): std.string.toupper and tolower should be (const(char)[]), not string)
	$(LI $(BUGZILLA 3304): Segfault using 'is' with a pointer enum.)
	$(LI $(BUGZILLA 3305): Segfault(expression.c) with recursive struct template alias expressions)
	$(LI $(BUGZILLA 3333): std.conv.to!(string, const int) error: cannot modify const)
	$(LI $(BUGZILLA 3335): minor warning cleanups)
	$(LI $(BUGZILLA 3336): ICE(glue.c) declaring AA with tuple key, only with -g)
	$(LI $(BUGZILLA 3340): std.string.split(S1 s, S2 delim) still doesn't work for char[])
	$(LI $(BUGZILLA 3353): storage class of a member function is propagated to default arguments)
	$(LI (unlisted): std.algorithm: bug in reduce when passed const arguments)
	$(LI (unlisted): std.stdio: fixed documentation example)
	$(LI (unlisted): std.utf: fixed decodeFront and decodeBack)
    )
)

$(VERSION 032, Sep 2, 2009, =================================================,

    $(WHATSNEW
	$(LI Improved exception message for assert(0) in Windows -release builds)
	$(LI Added support for:
---
a[i].var = e2
---
	and:
---
a[] = e
---
	in CTFE. $(I (thanks, Don!)))
	$(LI Member functions can now be used in CTFE)
	$(LI Operator overloading can now be used in CTFE)
	$(LI Nested functions can now be used in CTFE)
	$(LI CTFE error messages now explain why the function could not be
	interpreted at compile time)
	$(LI synchronized member functions now implicitly typed as shared.)
	$(LI std.algorithm: added minPos)
	$(LI std.format: added raw specifier for reading)
	$(LI added File.byChunk)
	$(LI std.algorithm: added more unittests and checks for user-based comparison passed to topN)
	$(LI std.math: replaced std.c with core.stdc; improved approxEqual to work with ranges, not only numbers or arrays)
	$(LI std.range: defined Take.popBack whenever sensible; improved iota to accept negative ranges and steps)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 601): statement.html - Formatting/markup errors in BNF)
	$(LI $(BUGZILLA 1461): Local variable as template alias parameter breaks CTFE)
	$(LI $(BUGZILLA 1600): Functions taking only one array cannot be called with property syntax)
	$(LI $(BUGZILLA 1604): Non-final method on final struct is too restrictive (closed with "invalid" advise))
	$(LI $(BUGZILLA 1605): break in switch with goto breaks in ctfe)
	$(LI $(BUGZILLA 1616): std/metastrings.d)
	$(LI $(BUGZILLA 1940): Phobos buildscripts do not work on x86_64)
	$(LI $(BUGZILLA 1948): CTFE fails when mutating a struct in an array)
	$(LI $(BUGZILLA 1950): CTFE doesn't work correctly for structs passed by ref)
	$(LI $(BUGZILLA 1969): ICE(cod1.c) using undefined operator with one const operand)
	$(LI $(BUGZILLA 1972): Foreach range statement breaks CTFE)
	$(LI $(BUGZILLA 2150): cannot get values from const variant)
	$(LI $(BUGZILLA 2277): array ops and const arrays incompatible)
	$(LI $(BUGZILLA 2398): writef("%x") for a pointer is always uppercase)
	$(LI $(BUGZILLA 2560): ICE(cod4.c) on invoking method that takes ref const struct parameter)
	$(LI $(BUGZILLA 2564): CTFE: the index in a tuple foreach is uninitialized (bogus error))
	$(LI $(BUGZILLA 2569): static arrays in CTFE functions don't compile)
	$(LI $(BUGZILLA 2575): gdb can not show code)
	$(LI $(BUGZILLA 2587): std.process.shell doesn't work for win32)
	$(LI $(BUGZILLA 2604): DW_TAG_module and GDB)
	$(LI $(BUGZILLA 2665): ICE(cod4.c) on certain const struct function return types)
	$(LI $(BUGZILLA 2784): Interfaces should be able to require type definitions (closed with "invalid" advise))
	$(LI $(BUGZILLA 2785): Interfaces should be able to require non-member functions (closed with "invalid" advise))
	$(LI $(BUGZILLA 2786): Interfaces should be able to require constructors (closed with "invalid" advise))
	$(LI $(BUGZILLA 2882): std.random.MersenneTwisterEngine without no seed)
	$(LI $(BUGZILLA 2925): Destructor not called)
	$(LI $(BUGZILLA 2937): postblit not called for foreach arg over array of structs)
	$(LI $(BUGZILLA 2940): null is null cannot be evaluated at compile time)
	$(LI $(BUGZILLA 2976): rename retreatN to retreat)
	$(LI $(BUGZILLA 2979): Xml tags with only attributes return as without attributes ElementParser.parse)
	$(LI $(BUGZILLA 2980): compiler error when writefln( uint ))
	$(LI $(BUGZILLA 2987): D2 phobos BigInt opMul doesn't work correctly)
	$(LI $(BUGZILLA 2988): Chain needs opIndexAssign.)
	$(LI $(BUGZILLA 2989): std.typetuple: add support for any static tuples)
	$(LI $(BUGZILLA 2992): (closed with "later" advise))
	$(LI $(BUGZILLA 2996): std.typetuple: add support for any static tuples)
	$(LI $(BUGZILLA 3000): iota should work with floats)
	$(LI $(BUGZILLA 3017): doc errors in std.range (on behalf of Steven Schveighoffer))
	$(LI $(BUGZILLA 3025): uniform(float,float) pops first, uniform(int,int) pops last)
	$(LI $(BUGZILLA 3037): Off-by-one error in Stride.length)
	$(LI $(BUGZILLA 3039): -vtls compiler flag not listed in man file)
	$(LI $(BUGZILLA 3058): [CTFE] Cannot return out of foreach range statement)
	$(LI $(BUGZILLA 3074): std.conv.to!(string)(int.min))
	$(LI $(BUGZILLA 3077): 3077 crash exiting main() without result code)
	$(LI $(BUGZILLA 3087): std.range.retro.opIndex out of range)
	$(LI $(BUGZILLA 3098): std.algorithm.reduce example can not compile)
	$(LI $(BUGZILLA 3100): ICE(cast.c) struct with members is shared)
	$(LI $(BUGZILLA 3132): std.string.split should be templated on mutable/const/immutable)
	$(LI $(BUGZILLA 3148): syntax error using invariant)
	$(LI $(BUGZILLA 3153): win32.mak tries to copy phobos.lib, gcstub.obj to nonexistent folder lib)
	$(LI $(BUGZILLA 3162): can't fully use compile-time floats as template parameters)
	$(LI $(BUGZILLA 3165): What kind of integer division does D use?)
	$(LI $(BUGZILLA 3166): "positive" -> "non-negative" in modulo operator description)
	$(LI $(BUGZILLA 3169): Segfault(cast.c) dividing ulong by int)
	$(LI $(BUGZILLA 3170): Forward reference of nested class fails if outer class is not plain)
	$(LI $(BUGZILLA 3183): Spec of align attribute needs work)
	$(LI $(BUGZILLA 3184): std.algorithm.until should work like "find")
	$(LI $(BUGZILLA 3185): osx is not a directory (complains cannot read std/c/osx/socket.d))
	$(LI $(BUGZILLA 3186): corrections for http://www.digitalmars.com/d/2.0/dmd-osx.html)
	$(LI $(BUGZILLA 3189): `std.conv.to` : check for a custom `to` method in classes/structs)
	$(LI $(BUGZILLA 3192): asm in a anonymous delegate crash the compiler)
	$(LI $(BUGZILLA 3195): `std.conv` pureness (closed with "later" advise))
	$(LI $(BUGZILLA 3196): Segfault(mtype.c) after almost any error involving a delegate literal)
	$(LI $(BUGZILLA 3197): Minor fixes and additions to std.traits)
	$(LI $(BUGZILLA 3199): sort(chain(...)) doesn't work in some cases)
	$(LI $(BUGZILLA 3205): CTFE: $ cannot be used in lvalues)
	$(LI $(BUGZILLA 3212): Error message says "mutable"; should say "immutable")
	$(LI $(BUGZILLA 3217): std.functional.binaryFunImpl doesn't support UDT with string functions , therefore neither does many std.algorithm functions)
	$(LI $(BUGZILLA 3218): Performance of std.xml.encode must be improved)
	$(LI $(BUGZILLA 3219): Inaccurate std.conv.to!(numeric)(numeric) error messages)
	$(LI $(BUGZILLA 3224): std.random documentation bugs)
	$(LI $(BUGZILLA 3229): No return or assert(0) at end of function)
	$(LI $(BUGZILLA 3236): Postblit called but no matching destructor)
	$(LI $(BUGZILLA 3239): std.conv.roundTo does not accept const/immutable/shared)
	$(LI $(BUGZILLA 3240): std.numeric.findRoot only works with real)
	$(LI $(BUGZILLA 3242): splitter does not handle input range made of a unique separator correctly)
	$(LI $(BUGZILLA 3245): Easy bug fix available for disabled unit test code in std.encoding)
	$(LI $(BUGZILLA 3246): ICE(init.c) using indexed array initializer on local array)
	$(LI $(BUGZILLA 3249): sort and setIntersection on array of struct or class)
	$(LI $(BUGZILLA 3253): DMD crashes on function pointer struct member initialization with function literal)
	$(LI $(BUGZILLA 3255): final switch broken with -w switch)
	$(LI $(BUGZILLA 3257): Spec is unclear describing string switch case labels)
	$(LI $(BUGZILLA 3260): "Error: undefined identifier backend" when compiling 'write' with 'wchar')
	$(LI $(BUGZILLA 3264): -O causes wrong "used before set" error when using enum.)
	$(LI $(BUGZILLA 3281): ICE(cod1.c) append returned struct to array)
	$(LI Fixed bug processing spaces in dmd's directory)
	$(LI Fixed assert failure on line 4823 in expression.c)
	$(LI Fixed OSX compile error on samples/d/dhry.d)
	$(LI std.format: fixed unlisted bug in documentation)
	$(LI std.random: uniform does not work when passed immutable data)
	$(LI std.range: fixed unlisted bug in Take.back)
	$(LI unlisted: made entropy work on const/immutable arrays)
    )
)

$(VERSION 031, July 6, 2009, =================================================,

    $(WHATSNEW
	$(LI Renamed root directory \dmd to \dmd2)
	$(LI Use of with symbols that shadow local symbols is no longer allowed)
	$(LI Added $(LINK2 statement.html#FinalSwitchStatement, final switch statements))
	$(LI Added $(LINK2 statement.html#CaseRangeStatement, case range statements))
	$(LI Implicit integral conversions that could result in loss of significant
	bits are no longer allowed.)
	$(LI Warning on no return expr; is now an error.)
	$(LI $(BUGZILLA 3080): dmd should output compilation errors to stderr, not stdout)
	$(LI $(BUGZILLA 3122): [patch] Adding support for fast and reliable build tools to the frontend)
	$(LI std.algorithm: Made std.algorithm.swap faster by having it use memcpy; added std.algorithm.group, std.algorithm.until, std.algorithm.nWayUnion, std.algorithm.largestPartialIntersectionWeighted; added additional constraints to std.algorithm.equal; changed signature of std.algorithm.topNIndex and std.algorithm.topNCopy to use an enum parameter instead of a confusing bool.)
	$(LI std.array: added array function.)
	$(LI std.conv: added Shin Fujishiro's code for printing and parsing enumerated values.)
	$(LI std.ctype: made isupper and tolower pure.)
	$(LI std.date: changed signature of benchmark to return ulong[] instead of uint[].)
	$(LI std.demangle: changed it to use the snazzy switch statement with ranged labels.)
	$(LI std.random: added randomSample)
	$(LI std.string: deprecated std.string.find and std.string.find, replaced with std.string.indexOf; deprecated std.string.rfind and std.string.irfind, replaced with std.string.lastIndexOf; added flag CaseSensitive for indexOf and lastIndexOf; removed startsWith and endsWith because std.algorithm defines them; defined std.string.byDchar.)
	$(LI std.traits: added isSomeChar, isPointer.)
	$(LI std.typetuple: replaced indexOf with indexOfType, kept the old name as an alias that will be deprecated.)
	$(LI std.utf: improved error messages.)
    )
    $(BUGSFIXED
	$(LI Fix dmd crash on multicore Windows.)
	$(LI Fixed unlisted bug in std.algorithm.startsWith)
	$(LI Fixed unlisted bug in std.algorithm.topN)
	$(LI Fixed unlisted bug in std.algorithm.topNIndex (empty index made it crash))
	$(LI Fixed unlisted bug in std.algorithm.setIntersection)
	$(LI Fixed unlisted bug in std.range.retro: retro'izing a range twice must return the original range)
	$(LI $(BUGZILLA 106): template - mixin sequence)
	$(LI $(BUGZILLA 810): Cannot forward reference template)
	$(LI $(BUGZILLA 852): ICE(toir.c) using local class in non-static nested function in nested static function)
	$(LI $(BUGZILLA 1343): Various errors with static initialization of structs and arrays)
	$(LI $(BUGZILLA 1358): ICE(root.c) on Unicode codepoints greater than 0x7FFFFFFF)
	$(LI $(BUGZILLA 1524): ICE(constfold.c) on using "is" with strings in CTFE)
	$(LI $(BUGZILLA 1984): Assertion failure: 'e1->type' on line 1198 in file 'constfold.c')
	$(LI $(BUGZILLA 2323): ICE(cgcs.c): taking address of a method of a temporary struct)
	$(LI $(BUGZILLA 2399): ICE(cgcod.c) on casting function to delegate)
	$(LI $(BUGZILLA 2429): std.stream.File incorrect flag parsing and sharing mode)
	$(LI $(BUGZILLA 2432): complex alias -> mtype.c:125: virtual Type* Type::syntaxCopy(): Assertion `0` failed.)
	$(LI $(BUGZILLA 2603): ICE(cgcs.c) on subtracting string literals)
	$(LI $(BUGZILLA 2843): ICE(constfold.c) with is-expression with invalid dot-expression in is-expression involving typeid)
	$(LI $(BUGZILLA 2865): RandomCover not random)
	$(LI $(BUGZILLA 2875): ICE(cgcod.c) setting delegate = &Struct.func)
	$(LI $(BUGZILLA 2884): ICE: Assert: 'template.c', line 3773, 'global.errors')
	$(LI $(BUGZILLA 2888): [PATCH] speedup for float * 2.0)
	$(LI $(BUGZILLA 2900): Array appending slowed drastically since integration of druntime)
	$(LI $(BUGZILLA 2915): [Patch]: Optimize -a*-b into a*b)
	$(LI $(BUGZILLA 2923): -O generates bad code for ?:)
	$(LI $(BUGZILLA 2932): bad e_ehsize (36 != 52))
	$(LI $(BUGZILLA 2952): Segfault on exit when using array ops with arrays of doubles larger than 8 elements)
	$(LI $(BUGZILLA 2974): Segfault(mtype.c) on auto function)
	$(LI $(BUGZILLA 2981): Bad code generation for structs containing invariants)
	$(LI $(BUGZILLA 2982): Assertion failure in function if() clause)
	$(LI $(BUGZILLA 3003): Need to implicitly add () on member template function calls)
	$(LI $(BUGZILLA 3014): ICE(template.c) instantiating template with tuple)
	$(LI $(BUGZILLA 3016): Errors in the documentation of std.math.acos)
	$(LI $(BUGZILLA 3026): Segfault with incomplete static array initializer)
	$(LI $(BUGZILLA 3044): Segfault(template.c) instantiating struct tuple constructor with zero arguments.)
	$(LI $(BUGZILLA 3071): nested func declaration parse problem)
	$(LI $(BUGZILLA 3078): NaN reported as equal to zero)
	$(LI $(BUGZILLA 3081): unaryFun can't be used to get element out of struct.)
	$(LI $(BUGZILLA 3095): wc example for D2 doesn't compile)
	$(LI $(BUGZILLA 3114): optlink failing on multicore machines)
	$(LI $(BUGZILLA 3117): dmd crash by *1)
	$(LI $(BUGZILLA 3121): recurrence does not generate the correct numbers)
	$(LI $(BUGZILLA 3128): Internal error: ..\ztc\cod4.c 2737)
	$(LI $(BUGZILLA 3130): Crashed with triple stars)
    )
)

$(VERSION 030, May 11, 2009, =================================================,

    $(WHATSNEW
	$(LI added $(B -vtls) compiler switch)
	$(LI $(RED classic global storage now defaults to TLS (Thread Local Storage)).
	This is a big change, see $(LINK2 migrate-to-shared.html, Migrating To Shared).)
        $(LI std.algorithm: added minPos. Improvements to Splitter suggested by Brad Roberts. Splitter now is bidirectional. Also Splitter has one extra trailing element if it ends with a separator. Added variadic arguments for setUnion and setIntersection. Added functions setSymmetricDifference and largestPartialIntersection. Improved BinaryHeap's interface and implementation.)
	$(LI std.array: Improvements to Appender. Now it works with string and other immutable-element arrays, and accepts ranges in put().)
        $(LI std.format: added raw specifier for reading)
	$(LI std.range: Added iota with two arguments. Added FrontTransversal and Transversal.)
        $(LI std.stdio: added File.byChunk)
	$(LI std.traits: Added isImplicitlyConvertible.)
	$(LI std.tuple: Added Tuple.opComp.)
	$(LI Folded in compiler changes by Unknown W. Brackets
	to support Solaris.)
	$(LI added .typeinfo to ClassInfo $(BUGZILLA 2836): Navigate from ClassInfo to TypeInfo)
    )
    $(BUGSFIXED
	$(LI Fix instruction scheduler bug on Linux)
	$(LI unlisted: made std.numeric.entropy work on const/immutable arrays)
	$(LI Fixed several problems associated with thread local storage)
        $(LI $(BUGZILLA 642): error: mixin "static this" into where it cannot be)
        $(LI $(BUGZILLA 713): circular const definitions with module operator "." cause the compiler to segfault)
        $(LI $(BUGZILLA 752): Assertion failure: 'e->type->ty != Ttuple' on line 4518 in file 'mtype.c')
        $(LI $(BUGZILLA 858): Forward reference to struct inside class crashes the compiler)
        $(LI $(BUGZILLA 884): Segfault in recursive template)
        $(LI $(BUGZILLA 934): Segfault taking mangleof a forward reference in a  template.)
        $(LI $(BUGZILLA 1011): illegal import declaration causes compile time segfault)
        $(LI $(BUGZILLA 1054): regression: circular aliases cause segfaults)
        $(LI $(BUGZILLA 1061): "asm inc [;" segfaults compiler.)
        $(LI $(BUGZILLA 1305): Compiler hangs with templated opCmp returning templated class)
        $(LI $(BUGZILLA 1385): Stack Overflow with huge array literal.)
        $(LI $(BUGZILLA 1428): Segfault on template specialization with delegates and tuples)
        $(LI $(BUGZILLA 1791): Segmentation fault with anon class in anon class and non-constant variable init)
        $(LI $(BUGZILLA 1916): segfault on invalid string concat)
        $(LI $(BUGZILLA 1946): Compiler crashes on attempt to implicit cast const typedef to non-const.)
        $(LI $(BUGZILLA 2048): DMD crash on CTFE that involves assigning to member variables of void-initialized struct)
        $(LI $(BUGZILLA 2061): wrong vtable call with multiple interface inheritance)
        $(LI $(BUGZILLA 2215): Forward reference enum with base type within a struct causes Segmentation Fault in the compiler)
        $(LI $(BUGZILLA 2309): Crash on a template mixing in a variadic template with an undefined template identifier)
        $(LI $(BUGZILLA 2346): ICE when comparing typedef'd class)
	$(LI $(BUGZILLA 2580): Documented WinMain for D2 is wrong)
	$(LI $(BUGZILLA 2633): incorrect ModuleInfo declaration in object.di)
	$(LI $(BUGZILLA 2695): pure functions can invoke impure function pointers)
	$(LI $(BUGZILLA 2807): Marking a nested function as 'pure' may cause bad code generations silently accepted)
        $(LI $(BUGZILLA 2821): struct alignment inconsistent with C for { int, long })
        $(LI $(BUGZILLA 2851): Segfault using C-style struct initializer with too few arguments)
	$(LI $(BUGZILLA 2865): RandomCover not random)
        $(LI $(BUGZILLA 2882): std.random.MersenneTwisterEngine without seed)
	$(LI $(BUGZILLA 2890): deadlock in std.stdio)
        $(LI $(BUGZILLA 2893): qualified types don't have an Unsigned counterpart)
	$(LI $(BUGZILLA 2906): writef problem with formatting floating point)
	$(LI $(BUGZILLA 2914): to!string(struct) is broken)
	$(LI $(BUGZILLA 2920): recursive templates blow compiler stack)
	$(LI $(BUGZILLA 2922): Egregiously bad hashing performance with strings)
    )
)

$(VERSION 029, Apr 19, 2009, =================================================,

    $(NEWPHOBOS
	$(LII std.algorithm,
	  $(LI Everything converted to ranges. Big disruption. Algorithms added.)
	)
	$(LII std.array,
	  $(LI Range primitives for arrays)
	  $(LI Appender template)
	  $(LI insert, replace functions)
	)
	$(LII std.bitmanip,
	  $(LI Bitfields of length 0 are defined to be always 0.)
	  $(LI The read functions for bitfields are const.)
	)
	$(LII std.contracts,
	  $(LI enforce accepts const(char)[] instead of string)
	  $(LI Added enforce overload that invokes a delegate on failure)
	  $(LI Added assumeSorted template)
	  $(LI Added structuralCast that implements, well, structural casting
	  (incomplete).)
	)
	$(LII std.conv,
	  $(LI Rewrote conversions with constrained templates.)
	  $(LI Added text() function that transforms everything into text.)
	)
	$(LII std.date,
	  $(LI Added a benchmark function that allows for simple timing measurements.)
	)
	$(LII std.file,

	  $(LI read, write, append, rename, remove, getSize, getTimes,
	  getAttributes, isfile, isdir, chdir, mkdir, mkdirRecurse, rmdir,
	  listdir, copy, take filename(s) by "in char[]")
	  $(LI Added function readText that reads and validates a text file)
	  $(LI Added function slurp that reads a file into an array of tuples.
	  Example:
---
auto a = slurp!(int, double)("filename", "%s, %s");
---
	  Each line in the file looks like e.g. "1, 2.3". slurp returns an array
	  of Tuple!(int, double) with the parsed content.
	  )
	)
	$(LII std.format,

	  $(LI Added vector parsing and printing with the specifier "%()". For
	  example, writefln("[%(s; )]", [1, 2, 3][]) writes "[1; 2; 3]". This
	  support is experimental and may be changed in the future.)
	  $(LI Added a formattedRead function (i.e., scanf that doesn't suck). The
	  implementation is incomplete but common cases are supported.)
	)
	$(LII std.functional,
	  $(LI Improved error messages)
	  $(LI Added configurable parameter names for functions as strings)
	  $(LI Added Adjoin template)
	)
	$(LII std.getopt,
	  $(LI Added support for parameterless delegates)
	)
	$(LII std.math,
	  $(LI Intrinsics std.math.yl2x and yl2xp1 added. Improves performance of
	   std.math.log() and similar functions (and they are now pure nothrow). )
	  )
	$(LII std.mmfile,
	  $(LI Minor cosmetic changes)
	)
	$(LII std.numeric,

	  $(LI Added type CustomFloat that allows defining specialized floating-point
	  numbers (e.g. 16-bit floats, positive floats etc.))
	  $(LI Added FPTemporary as the best type to store temporary values.)
	  $(LI Templatized oppositeSigns)
	  $(LI Added Euclidean distance)
	  $(LI Added dotProduct)
	  $(LI Added cosineSimilarity)
	  $(LI Added normalize)
	  $(LI Added string kernel functions gapWeightedSimilarity,
	  gapWeightedSimilarityNormalized, gapWeightedSimilarityIncremental.)
	)
	$(LII std.outbuffer,
	  $(LI Added a few missing overloads of write())
	)
	$(LII std.path,
	  $(LI getDrive now works with all string types)
	  $(LI isabs accepts in char[])
	  $(LI join accepts variadic in char[])
	  $(LI fnmatch works with in char[])
	)
	$(LII std.random,

	  $(LI Added RandomCover that covers a given range in a random manner)
	  $(LI Eliminated the old-fashioned random functions)
	  $(LI Defined a default random object that simplifies calls to the random
	  functions)
	  $(LI Changed generators to obey the range interface. So now you can write:
---
Random r;
foreach (n; take(100, uniform(0, 100))) { ... }
---
	  )
	)
	$(LII std.range (new file),
	  $(LI Range manipulation stuff.)
	)
	$(LII std.regex (new file),
	  $(LI Regular expression library with wide char support, simplified
	  interface, better speed etc.)
	)
	$(LII std.regexp,
	  $(LI Scheduled for deprecation. Use std.regex instead.)
	)
	$(LII std.stdio,
	  $(LI Major breaking changes: introduced the File struct.  Now stdin,
	  stdout, stderr are instances of the File struct.)
	  $(LI Due to bugs in the compiler, the copy constructor and destructor of
	  File are commented out. Walter will look into fixing the issues soon.
	  File should work fine, but you need to close it manually.)
	  $(LI A byRecord iteration mode makes it pretty easy to iterate structured
	  text files.)
	  $(LI writef and writefln now require a string as their first argument.)
	)
	$(LII std.string,
	  $(LI strip, stripl, stripr, startsWith, endsWith now work with any string type)
	)
	$(LII std.typecons,
	  $(LI Added constructors, assignment operator, length, toString, and slice
	  to Tuple.)
	)
	$(LII std.utf,
	  $(LI toUTF16z accepts in char[])
	)
	$(LII std.variant,
	  $(LI Added support for Variants that contain vectors and hashes of themselves)
	)
	$(LII std.c.stdio,
	  $(LI Added fopen64 and friends)
	)
    )
    $(WHATSNEW
	$(LI Added template function literals)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 675): %a format has an out-by-1 bug for denormals)
	$(LI $(BUGZILLA 2199): Segfault using array operation in function call)
	$(LI $(BUGZILLA 2203): typeof(class.template.foo) crashes compiler)
	$(LI $(BUGZILLA 2577): DMD crashes on foreach of undefined identifier)
	$(LI $(BUGZILLA 2808): 'nothrow' nested functions cannot be parsed)
	$(LI $(BUGZILLA 2812): sqrt(2.0) is about -2.7341e-53)
    )
)

$(VERSION 028, Apr 7, 2009, =================================================,

    $(WHATSNEW
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1586): DMD and GDC segfaults on incomplete code segment)
	$(LI $(BUGZILLA 2064): Segfault with mixin(for/foreach) with empty loop body)
	$(LI $(BUGZILLA 2812): sqrt(2.0) is about -2.7341e-53)
	$(LI $(BUGZILLA 2804): Impure nested functions should be legal inside pure functions)
    )
)

$(VERSION 027, Mar 31, 2009, =================================================,

    $(WHATSNEW
	$(LI Most functions in std.math are now pure nothrow. Improved speed of std.math.hypot.)
	$(LI Added response files for Linux and OSX)
	$(LI Added $(LINK2 class.html#AliasThis, $(B alias this)))
	$(LI $(BUGZILLA 2746): Make float.init signalling NaN by default)
	$(LI On Windows, if there are multiple source files on the command
	 line they are now read with a background thread. This may speed up
	 compilation.)
	$(LI Folded in patches for LDC compatibility from Tomas Lindquist Olsen)
	$(LI Removed $(B etc.gamma) from the library.)
    )
    $(BUGSFIXED
	$(LI std.math.hypot is wrong for subnormal arguments)
	$(LI Fix bug where / wasn't recognized as a path separator on Windows.)
	$(LI $(BUGZILLA 920): Fix one more out of date reference to 'auto' rather than 'scope')
	$(LI $(BUGZILLA 1645): can override base class' const method with non-const method)
	$(LI $(BUGZILLA 2319): "Win32 Exception" not very useful)
	$(LI $(BUGZILLA 2336): link to nonexistent std_array.html)
	$(LI $(BUGZILLA 2570): Patch for some mistakes in Ddoc comments)
	$(LI $(BUGZILLA 2574): std.c.stdio doesn't compile: va_list not defined!)
	$(LI $(BUGZILLA 2591): custom allocator new argument should be size_t instead of uint)
	$(LI $(BUGZILLA 2595): template ctors crash compiler)
	$(LI $(BUGZILLA 2596): Variadic constructors don't compile)
	$(LI $(BUGZILLA 2626): template function not working against template struct instantiated with default arguments)
	$(LI $(BUGZILLA 2674): Copy postblit constructor this(this) not called for members)
	$(LI $(BUGZILLA 2689): seek behaves incorrectly on MAC OSX)
	$(LI $(BUGZILLA 2692): alignment of double on x86 linux is incorrect)
	$(LI $(BUGZILLA 2700): typeof tests stops compilation abruptly)
	$(LI $(BUGZILLA 2705): Response file size cannot exceed 64kb)
	$(LI $(BUGZILLA 2711): -H produces bad headers files if function defintion is templated and have auto return value)
	$(LI $(BUGZILLA 2722): ICE with variadic template parameters)
	$(LI $(BUGZILLA 2723): ICE with variadic template parameters, different case)
	$(LI $(BUGZILLA 2724): Persistent segfaults in templated code)
	$(LI $(BUGZILLA 2725): Pattern matching in static if not working with variadic arguments)
	$(LI $(BUGZILLA 2727): std.date Cyclic dependency)
	$(LI $(BUGZILLA 2728): Bogus Error message on const ref return)
	$(LI $(BUGZILLA 2729): hash_t undocumented and unnecessary)
	$(LI $(BUGZILLA 2730): Restriction on op= can be lifted)
	$(LI $(BUGZILLA 2731): Errors in associative array example)
	$(LI $(BUGZILLA 2739): _argptr is invalid for functions nested in class methods)
	$(LI $(BUGZILLA 2743): dumpobj gives "buss error" on Tiger)
	$(LI $(BUGZILLA 2744): wrong init tocbuffer of forstatement)
	$(LI $(BUGZILLA 2745): missing token tochars in lexer.c)
	$(LI $(BUGZILLA 2747): improper toCBuffer of funcexp)
	$(LI $(BUGZILLA 2750): Optimize slice copy with size known at compile time)
	$(LI $(BUGZILLA 2751): incorrect scope storage class vardeclaration tocbuffer)
	$(LI $(BUGZILLA 2752): std.xml does not encode CData correctly)
	$(LI $(BUGZILLA 2754): The error message regarding implicit conversion to shared doesn't mention shared in the message.)
	$(LI $(BUGZILLA 2755): ICE on invalid ref returns in linked objects: Assertion failure: 'type' on line 6566 in file 'expression.c'. No ICE or error if invalid code is local to the file.)
	$(LI $(BUGZILLA 2756): Bad code generation for pure nothrow math functions)
	$(LI $(BUGZILLA 2761): Unreachable statement warning in std.string)
	$(LI $(BUGZILLA 2763): std.mangle.demangle not translating 'ya')
	$(LI $(BUGZILLA 2766): DMD hangs with 0%cpu)
	$(LI $(BUGZILLA 2767): DMD incorrectly mangles NTFS stream names)
	$(LI $(BUGZILLA 2772): lib can't open response file)
    )
)

$(VERSION 026, Mar 3, 2009, =================================================,

    $(WHATSNEW
	$(LI Escape string literals deprecated, see $(BUGZILLA 2658))
	$(LI Tripled speed of exp, expm1, and exp2. std.math is now less dependent on the C standard library.)
	$(LI Added $(LINK2 struct.html#nested, nested structs).)
	$(LI Added buildable dmd source.)
	$(LI Many changes to std.math for speed, accuracy, and Tango compatibility:
	   $(UL
           $(LI Improved accuracy of exp, expm1, exp2, sinh, cosh, tanh on Mac OSX,
           and tripled speed on all platforms.)
	   $(LI Now using IEEE754-2008 camelCase names for isNaN, isFinite,
           isNormal, isSubnormal, isInfinity. Aliases for the old names have been retained.)
	   $(LI The non-functional nan(char[]) is replaced with NaN, getNaNpayload.)
	   )
          )
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1603): String literals bind to pointer types)
	$(LI $(BUGZILLA 1629): Link error: Previous Definition Different:  blablah__initZ)
	$(LI $(BUGZILLA 1662): Falls back to libphobos if -debuglib isn't used when -g is)
	$(LI $(BUGZILLA 1681): cast(real) ulong.max == 0)
	$(LI $(BUGZILLA 2416): Slice of typedef'ed array should preserve the typedef'ed type)
	$(LI $(BUGZILLA 2597): auto return doesn't work for a variety of cases)
	$(LI $(BUGZILLA 2612): immutable not accepted wherever invariant is)
	$(LI $(BUGZILLA 2619): Locally-instantiated structs are not instantiated locally)
	$(LI $(BUGZILLA 2621): ref binds to rvalues of user-defined types)
	$(LI $(BUGZILLA 2622): ref returns not allowed in complex template)
	$(LI $(BUGZILLA 2623): Function type drops ref spec)
	$(LI $(BUGZILLA 2670): std.file.read() should read files of 0 length)
	$(LI $(BUGZILLA 2673): Static constructors sometimes do not run when compiling with -lib)
	$(LI $(BUGZILLA 2675): cannot foreach structs with copy constructor)
	$(LI $(BUGZILLA 2676): alias parameters not matched in concept if clause)
	$(LI $(BUGZILLA 2677): Alias type parameters not visible in concept-if clauses)
	$(LI $(BUGZILLA 2678): for loops are already assumed to terminate)
	$(LI $(BUGZILLA 2679): Spurious "warning - " messages and erratic behaviour with is(typeof({void function}())))
	$(LI $(BUGZILLA 2684): Associative arrays have wrong opIndex signatures)
	$(LI $(BUGZILLA 2690): DMD aborts with MALLOC_CHECK_ set)
    )
)

$(VERSION 025, Feb 14, 2009, =================================================,

    $(WHATSNEW
	$(LI Added Mac OSX support.)
	$(LI Separated bin and lib directories into windows, linux,
	and osx.)
	$(LI No longer need to download dmc to use the windows version.)
	$(LI Use version(OSX) for Mac OSX. Although version(darwin) is
	also supported for the time being, it is deprecated.)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 2448): template return by reference causes seg fault)
    )
)

$(VERSION 023, Jan 2, 2009, =================================================,

    $(WHATSNEW
	$(LI Improved speed of long division.)
	$(LI Optimizer now takes advantage of immutable and pure.)
	$(LI Added predefined $(LINK2 version.html#PredefinedVersions, version)
	 $(B D_Ddoc) which is predefined when $(B -D) switch is thrown.)
	$(LI the type of a string literal is now $(CODE invariant(char)[])
	 rather than $(CODE invariant(char)[length_of_string]). It is still
	 implicitly convertible to the latter. This is intended to reduce
	 template instantiation bloat.)
	$(LI Undid fix for $(BUGZILLA 2500), as the fix was arguably worse
	 than the bug.)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1078): Frontend uses of 'auto' where 'scope' should be used)
	$(LI $(BUGZILLA 2517): DDoc omits abstract on classes)
	$(LI $(BUGZILLA 2518): scope(success) not execuate and RAII variable destructor is not called)
	$(LI $(BUGZILLA 2519): Segfault when >> used in an invalid slice)
	$(LI $(BUGZILLA 2527): Alias Template Params Are Always Same Type As First Instantiation (according to typeof(x).stringof))
	$(LI $(BUGZILLA 2531): DDoc not generated correctly for struct methods inside static if)
	$(LI $(BUGZILLA 2533): compiler falls with "assertion failed" message on wrong code)
	$(LI $(BUGZILLA 2534): dmd.conf is wrong)
	$(LI $(BUGZILLA 2537): compiler crashes on this code:)
	$(LI $(BUGZILLA 2541): cannot use aliased type for decl of foreach variable)
	$(LI $(BUGZILLA 2542): array casts behave differently at compile and runtime)
    )
)

$(VERSION 022, Dec 11, 2008, =================================================,

    $(WHATSNEW
	$(LI Changed IUnknown to use the extern(System) interface rather
	that extern(Windows).)
	$(LI Pure functions now get semantically checked.)
	$(LI Nothrow functions now get semantically checked.)
	$(LI $(D shared) is now a type constructor.)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1518): Crash using 'scope', 'with' and undefined 'RegExp')
	$(LI $(BUGZILLA 1649): Variant coercion fails with delegates)
	$(LI $(BUGZILLA 1685): Array index is evaluated twice)
	$(LI $(BUGZILLA 1933): Delimited string constants can cause segfault)
	$(LI $(BUGZILLA 1963): -H creates broken headers)
	$(LI $(BUGZILLA 2041): Spec implies relationship between interfaces and COM objects)
	$(LI $(BUGZILLA 2105): added patch)
	$(LI $(BUGZILLA 2441): header file generation translates enum to manifest)
	$(LI $(BUGZILLA 2468): result type of AndAndExp and OrOrExp deduced incorrectly)
	$(LI $(BUGZILLA 2489): import in struct causes assertion failure)
	$(LI $(BUGZILLA 2490): extern(C++) can not handle structs as return types)
	$(LI $(BUGZILLA 2491): druntime GC wrongly frees data pointed to by TLS.)
	$(LI $(BUGZILLA 2492): ICE building on Linux with -lib option)
	$(LI $(BUGZILLA 2499): Template alias default value cannot be template instantiation)
	$(LI $(BUGZILLA 2500): template struct methods are left unresolved if imported from multiple modules)
	$(LI $(BUGZILLA 2501): member function marked as final override ignores override requirements)
	$(LI $(BUGZILLA 2503): Error 42: Symbol Undefined _D3std7process6systemFAyaZi)
	$(LI $(BUGZILLA 2506): Can't initialize const member in ctor if it is accessed via this.member syntax)
	$(LI Incorporated some of the patches from $(BUGZILLA 1752))
	$(LI $(D extern __thread) now works on Linux.)
    )
)

$(VERSION 021, Nov 25, 2008, =================================================,

    $(WHATSNEW
	$(LI Added $(B -safe) switch and $(CODE module(system) Identifier;) syntax.)
	$(LI Added range support to foreach statement.)
	$(LI $(B scope) parameter storage class means the parameter will
	 not 'escape' the scope of the function invocation.
	 Using this for delegate parameters will prevent some closure allocations
	 by the calling function.)
	$(LI The $(B lazy) storage class now implies $(B scope) so that lazy
	 arguments won't trigger a heap allocated closure.)
	$(LI The 'this' parameter to struct member functions is now a
	 reference type, rather than a pointer.
	 $(RED This breaks existing code.)
	 )

	$(LI More changes to druntime:
	$(TABLE
	$(TR $(TH from) $(TH to))
	$(TRENAME OutOfMemoryException, OutOfMemoryError)
	$(TRENAME SwitchException, SwitchError)
	$(TRENAME HiddenFuncException, HiddenFuncError)
	$(TRENAME ArrayBoundsException, RangeError)
	$(TRENAME AssertException, AssertError)
	$(TRENAME FinalizeException, FinalizeError)
	$(TRENAME onArrayBoundsError, onRangeError)
	$(TRENAME stdc.*, core.stdc.*)
	$(TRENAME sys.*, core.sys.*)


	)
	)

	$(LI Added core.runtime.loadLibrary() as an experimental feature for
	loading dynamic libraries (Win32 only at the moment).)
	$(LI Added core.runtime.unloadLibrary() as an experimental feature for
	unloading dynamic libraries previously loaded by loadLibrary().)
	$(LI core.thread.sleep() accepts a long integer specifying the sleep interval
	in 100 nanosecond intervals (the previous release notes said this was a
	float, IIRC).)
	$(LI It is no longer necessary to link in druntime separately, it is
	inserted into libphobos2.a.)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 313): Fully qualified names bypass private imports)
	$(LI $(BUGZILLA 920): SPEC: Auto classes referenced where scope should be used)
	$(LI $(BUGZILLA 929): Resizing array of associative arrays (uint[char[]][]) causes infinite loop / hang)
	$(LI $(BUGZILLA 1372): Compiler accepts pragma(msg,))
	$(LI $(BUGZILLA 1610): Enum.stringof is int, not the name of the enum)
	$(LI $(BUGZILLA 1663): pragma(lib, "") don't work on linux)
	$(LI $(BUGZILLA 1797): Documentation comments - ///)
	$(LI $(BUGZILLA 2428): Accessing item in enum'd array produced compiler error)
	$(LI $(BUGZILLA 2429): std.stream.File incorrect flag parsing and sharing mode)
	$(LI $(BUGZILLA 2431): Internal error: ../ztc/cgcod.c 1031 when using -O)
	$(LI $(BUGZILLA 2470): Cannot build libraries from other libraries)
	$(LI unittest functions now always use D linkage)
    )
)

$(VERSION 020, Oct 20, 2008, =================================================,

    $(WHATSNEW
	$(LI Improved performance of AAs by rebalancing trees when rehashing.)
	$(LI $(D_KEYWORD immutable) now is implemented.)
	$(LI $(BUGZILLA 2344): Two wrong lookups for array functions)
	$(LI $(BUGZILLA 2345): Return by $(LINK2 function.html#ref-functions, reference) should be allowed)
	$(LI $(CODE Posix) is now a predefined identifier when compiling under Linux)
	$(LI Based on Sean Kelly's hard work, Phobos has been split into
	two libraries, druntime.lib and phobos.lib. This will enable
	better integration with Tango.
	The user source code changes are:
	$(TABLE
	$(TR $(TH from) $(TH to))
	$(TRENAME bit, bool)
	$(TRENAME _d_OutOfMemory(), onOutOfMemoryError())
	$(TRENAME import std.asserterror;, import core.exception;)
	$(TRENAME import std.hiddenfunc;, import core.exception;)
	$(TRENAME import std.switcherr;, import core.exception;)
	$(TRENAME import std.array;, import core.exception;)
	$(TRENAME import std.outofmemory;, import core.exception;)
	$(TRENAME import std.gc;, import core.memory;)
	$(TRENAME import std.thread;, import core.thread;)
	$(TRENAME SwitchError, SwitchException)
	$(TRENAME AssertError, AssertException)
	$(TRENAME HiddenFuncError, HiddenFuncException)
	$(TRENAME ArrayBoundsError, ArrayBoundsException)
	$(TRENAME std.gc.fullCollect(), GC.collect())
	$(TRENAME std.gc.*(), memory.gc_*())
	$(TRENAME _moduleUnitTests(), import runtime; runModuleUnitTests())
	$(TR $(TD $(CODE printf)) $(TD add $(CODE import std.c.stdio;)))
	)
	Changes to thread:
	$(UL
	$(LI The thread handle isn't exposed to the user.  This can always be obtained using the appropriate OS calls from within the thread.)
	$(LI There is no druntime equivalent for Thread.pause() and Thread.resume().  The closest is thread_suspendAll() and thread_resumeAll()--extern (C) calls meant for use by the GC.)
	$(LI Thread.wait() is renamed to Thread.join().)
	$(LI Sleep functionality is available as Thread.sleep(double), where the parameter represents the number of seconds to sleep (fractional values accepted, obviously).)
	)
	This is a big change, and expect some problems for a release or two
	with this.
	)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1229): Linker fills disk)
	$(LI $(BUGZILLA 2332): Initializing const or invariant hashes croaks)
	$(LI $(BUGZILLA 2333): Hash initializer does not work)
	$(LI $(BUGZILLA 2336): link to nonexistent std_array.html)
	$(LI $(BUGZILLA 2340): Template properties don't work)
	$(LI $(BUGZILLA 2341): Double destruction without intervening copy)
	$(LI $(BUGZILLA 2362): Confusing description of 'aliasing of invariant with mutable'?)
	$(LI $(BUGZILLA 2363): Spurious () required after function name when used with array in prefix form)
	$(LI $(BUGZILLA 2366): Const member function syntax is missing)
	$(LI $(BUGZILLA 2368): Calling a function with an address of another function, then calling a returned object is rejected)
	$(LI $(BUGZILLA 2373): freebsd select does not accept values  &gt; 999,999)
	$(LI $(BUGZILLA 2376): CTFE fails on array literal of array literals of chars)
	$(LI $(BUGZILLA 2380): static struct initializer accepted as non static initializer is not documented)
	$(LI $(BUGZILLA 2383): default arguments can implicitly access private global variables that are not visible at call site)
	$(LI $(BUGZILLA 2385): spec says all structs are returned via hidden pointer on linux, but it uses registers)
	$(LI $(BUGZILLA 2390): Missing warning on conversion from int to char)
    )
)

$(VERSION 019, Sep 2, 2008, =================================================,

    $(WHATSNEW
	$(LI Added $(LINK2 struct.html#Struct-Constructor, struct constructors).)
	$(LI Special member functions _ctor, _dtor, etc., now have two
	 leading _ in order to not conflict with the user identifier space.)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1322): foreach bypasses invariant)
	$(LI $(BUGZILLA 1615): inout is allowed in foreach of string literal)
	$(LI $(BUGZILLA 1627): ICE with a method called _ctor)
	$(LI $(BUGZILLA 1633): Nonsensical "C style cast illegal" message with !is)
	$(LI $(BUGZILLA 1771): dmd fails to execute on linux)
	$(LI $(BUGZILLA 1773): excessively long integer literal)
	$(LI $(BUGZILLA 1785): Mixing in an incorrect array literal causes infinite loop.)
	$(LI $(BUGZILLA 2176): Assertion failure: 'sz == es2->sz' on line 1339 in file 'constfold.c' (concatenating strings of different types))
	$(LI $(BUGZILLA 2183): Bad formatting in std.c.stdlib)
	$(LI $(BUGZILLA 2190): toHash documentation is deprecated [D2.0])
	$(LI $(BUGZILLA 2232): DMD generates invalid code when an object file is compiled -inline)
	$(LI $(BUGZILLA 2241): DMD abort)
	$(LI $(BUGZILLA 2243): const bool = is(function literal), badly miscast)
	$(LI $(BUGZILLA 2262): -inline breaks -lib library)
	$(LI $(BUGZILLA 2286): movmskpd compiled incorrectly)
	$(LI $(BUGZILLA 2287): std.conv should accept structs defining toString)
	$(LI $(BUGZILLA 2289): Stack overflow on very large BigInt to string.)
	$(LI $(BUGZILLA 2308): CTFE crash on foreach over nonexistent variable)
	$(LI $(BUGZILLA 2311): Static destructors in templates are never run)
	$(LI $(BUGZILLA 2314): Crash on anonymous class variable instantiation)
	$(LI $(BUGZILLA 2316): std.file docs are out of date)
	$(LI $(BUGZILLA 2317): asm offsetof generates: Internal error: ../ztc/cod3.c 2651)
    )
)

$(VERSION 018, Aug 7, 2008, =================================================,

    $(WHATSNEW
	$(LI Now supports $(LINK2 arrays.html#array-operations, array operations).)
    )
    $(BUGSFIXED
	$(LI Added hash to generated module names when building libs to reduce collisions)
	$(LI $(BUGZILLA 1622): parameters to TypeInfo_Struct.compare seem to be switched around.)
	$(LI $(BUGZILLA 1644): Template instantiation should automatically cast to const to make const-ness irrelevant when argument is const anyways)
	$(LI $(BUGZILLA 2216): bad code generation for static arrays of zero length static arrays)
	$(LI $(BUGZILLA 2223): Typo in error message)
	$(LI $(BUGZILLA 2231): missing bigint document)
	$(LI $(BUGZILLA 2242): linux system calls are canceled by GC)
	$(LI $(BUGZILLA 2247): bad header file generated for if (auto o = ...) {})
	$(LI $(BUGZILLA 2248): .di should be a supported file extension)
	$(LI $(BUGZILLA 2250): Update of user32.lib and kernel32.lib)
	$(LI $(BUGZILLA 2254): Size of executable almost triples)
	$(LI $(BUGZILLA 2258): Docs -> Inline Assembler -> Operand Types -> qword missing)
	$(LI $(BUGZILLA 2259): Assertion failure: '0' on line 122 in file 'statement.c')
	$(LI $(BUGZILLA 2266): opEquals documentation still says it returns int)
	$(LI $(BUGZILLA 2269): D BUG: cosine of complex)
	$(LI $(BUGZILLA 2272): synchronized attribute documentation)
	$(LI $(BUGZILLA 2273): Whitespace is not inserted after commas)
    )
)

$(VERSION 017, Jul 11, 2008, =================================================,

    $(WHATSNEW
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 2207): overload resolution fails with deprecation)
	$(LI $(BUGZILLA 2208): Deprecated function declarations cannot use deprecated types)
	$(LI $(BUGZILLA 2209): Typo in doc for offsetof)
	$(LI $(BUGZILLA 2212): phobos itself should be able to be compiled with '-w' switch)
	$(LI $(BUGZILLA 2264): typo in documentation regarding atof.)
    )
)

$(VERSION 016, Jul 8, 2008, =================================================,

    $(WHATSNEW
        $(LI re-implemented $(B internal.monitor) in D. Rationalized $(B internal.object))
	$(LI $(BUGZILLA 288): changed return type of $(B opEquals) from int
	 to bool. This necessitates doing a grep for opEquals and
	 $(RED changing all the return values).
	)
	$(LI Added $(B .__vptr) and $(B .__monitor) properties for class objects
	 for use in the internal runtime library.
	)
	$(LI Made $(LINK2 rdmd.html, rdmd)'s source available through svn, see $(LINK http://dsource.org/projects/phobos/browser/trunk/tools/rdmd.d))
	$(LI Simplified $(B std.algorithm) by fusing together higher-order functions taking an alias and their counterparts taking a string)
	$(LI Added module $(B std.array) containing array operations: $(B insert), $(B erase), and $(B replace))
	$(LI Changed the $(B enforce)'s implementation to generate smaller code per call)
	$(LI Changed $(B std.functional.binaryFun) to work with strings and function aliases alike)
	$(LI In $(B std.getopt), added $(B optChar), $(B assignChar), and $(B endOfOptions), per popular demand :o|)
	$(LI In $(B std.math), replaced a bunch of $(B const)s with $(B enum)s)
	$(LI In $(B std.numeric), added Don Clugston as author and operated minor documentation fixes)
	$(LI Improved $(B std.stdio.chunks) to take an iteration tally in addition to the chunk)
    )
    $(BUGSFIXED
	$(LI $(NG_digitalmars_D_announce 12322): mixin regression)
	$(LI $(BUGZILLA 203): std.format.doFormat() pads width incorrectly on Unicode strings)
	$(LI $(BUGZILLA 211): Linking error with alias mixin params and anonymous methods)
	$(LI $(BUGZILLA 224): Incorrect warning "no return at end of function")
	$(LI $(BUGZILLA 252): -w and switch returns = bogus "no return at end of function" warning)
	$(LI $(BUGZILLA 253): Invalid &lt;dl&gt; tag generated by Ddoc)
	$(LI $(BUGZILLA 294): DDoc: Function templates get double and incomplete documentation)
	$(LI $(BUGZILLA 398): No way to abort compilation in a doubly recursive mixin)
	$(LI $(BUGZILLA 423): dmd ignores empty commandline arguments)
	$(LI $(BUGZILLA 515): Spec incorrect in where .offsetof can be applied)
	$(LI $(BUGZILLA 520): Invariants allowed to call public functions)
	$(LI $(BUGZILLA 542): Function parameter of a deprecated type (other than a class) is not caught)
	$(LI $(BUGZILLA 543): Function return of a deprecated type is not caught)
	$(LI $(BUGZILLA 544): Variable declared of a deprecated type (other than a class) is not caught)
	$(LI $(BUGZILLA 545): Attempt to access a static built-in property of a deprecated struct, union, enum or typedef is not caught)
	$(LI $(BUGZILLA 547): Accessing a deprecated member variable through an explicit object reference is not caught)
	$(LI $(BUGZILLA 548): Accessing a value of a deprecated enum is not caught)
	$(LI $(BUGZILLA 566): Adding non-static members and functions to classes using a template doesn't error)
	$(LI $(BUGZILLA 570): Bogus recursive mixin error)
	$(LI $(BUGZILLA 571): class instance member template returns strange value)
	$(LI $(BUGZILLA 572): parse error when using template instantiation with typeof)
	$(LI $(BUGZILLA 581): Error message w/o line number in dot-instantiated template)
	$(LI $(BUGZILLA 617): IFTI doesn't use normal promotion rules for non-template parameters)
	$(LI $(BUGZILLA 870): contradictory error messages for templates)
	$(LI $(BUGZILLA 951): Missing line number: no constructor provided for a class derived from a class with no default constructor)
	$(LI $(BUGZILLA 1097): Missing line number: casting array to array of different element size)
	$(LI $(BUGZILLA 1158): Missing line number: invalid mixin outside function scope)
	$(LI $(BUGZILLA 1176): Error missing file and line number)
	$(LI $(BUGZILLA 1187): Segfault with syntax error in two-level mixin.)
	$(LI $(BUGZILLA 1194): fcmov* emmits incorrect code)
	$(LI $(BUGZILLA 1207): Documentation on destructors is confusing)
	$(LI $(BUGZILLA 1341): typeof(int) should probably be legal)
	$(LI $(BUGZILLA 1601): shr and shl error message is missing line numbers)
	$(LI $(BUGZILLA 1612): No file/line number for using an undefined label in inline assembly)
	$(LI $(BUGZILLA 1912): Error without line number (Tuple, invalid value argument))
	$(LI $(BUGZILLA 1936): Error with no line number (array dimension overflow))
	$(LI $(BUGZILLA 2076): asm: offset has wrong docs and error without line number)
	$(LI $(BUGZILLA 2161): Modify compiler to pass array TypeInfo to _adEq and _adCmp instead of element TypeInfo)
	$(LI $(BUGZILLA 2178): 3 errors without line number: typeof)
	$(LI $(BUGZILLA 2188): man-or-boy test fails with access violation)
	$(LI Fixed bugs in $(B std.file.rename) and $(B std.file.remove) on Linux)
	$(LI Fixed documentation in $(B std.typecons))
    )
)

$(VERSION 015, Jun 17, 2008, =================================================,

    $(WHATSNEW
	$(LI $(LINK2 template.html#aliasparameters, Template alias arguments)
	 can now be literals.)
	$(LI $(LINK2 template.html#function-templates, Function templates)
	 can now deduce the return type if they
	 are declared with $(CODE auto).)
	$(LI Non-lvalues are no longer matched to $(CODE ref) and $(CODE out)
	 parameters when
	 $(LINK2 function.html#function-overloading, overloading).)
	$(LI Relaxed hidden hijacking detection when hidden function is disjoint
	 from overloading with any other virtual function in the
	 $(LINK2 function.html#function-inheritance, hierarchy).)
	$(LI Added $(LINK2 version.html#PredefinedVersions, version identifier
	 $(B D_PIC)) when $(B -fPIC) switch is used.)
	$(LI Added $(LINK2 template.html#Constraint, $(I Constraint)s) to
	 templates.)
    )
    $(BUGSFIXED
	$(LI $(BUGZILLA 1383): Implicit Function Instantiation with typesafe-variadic of delegates doesn't work)
	$(LI $(BUGZILLA 1559): version statement makes code outside of it disappear)
	$(LI $(BUGZILLA 1675): "Identifier too long" error with OMF object files)
	$(LI $(BUGZILLA 1947): ICE (Assertion failure: '0' on statement.c:123) with null mixin)
	$(LI $(BUGZILLA 1963): -H creates broken headers)
	$(LI $(BUGZILLA 2098): Outdated docs)
	$(LI $(BUGZILLA 2099): Text and Sample Code Disagree (non-static local invariant declaration))
	$(LI $(BUGZILLA 2112): the type of undefined variable incorrectly assumed to be int)
	$(LI $(BUGZILLA 2118): Inconsistent use of string vs invariant(char[]) in doc)
	$(LI $(BUGZILLA 2123): Anonymous class crashes)
	$(LI $(BUGZILLA 2129): foreach won't work with invariant limits)
	$(LI $(BUGZILLA 2132): CTFE: can't evaluate ~= at compile time, D2 only.)
	$(LI $(BUGZILLA 2133): anonymous enum without {} doesn't work as asm value)
	$(LI $(BUGZILLA 2136): typeof(super(...)) counted as a constructor call)
	$(LI $(BUGZILLA 2140): static if as final statement with no code causes containing code to be skipped)
	$(LI $(BUGZILLA 2143): Mixed-in identifier is not recognized by static if)
	$(LI $(BUGZILLA 2144): 'is' is defined to be the same as '==' for non-class and non-array types, but does not call opEquals)
	$(LI $(BUGZILLA 2145): Phobos buildsystem unable to build html)
	$(LI $(BUGZILLA 2146): Multiple execution of 'static this' defined in template)
	$(LI $(BUGZILLA 2149): Auto variables loose the keyword "auto" in di files generated with -H option.)
    )
)

$(VERSION 014, May 16, 2008, =================================================,

    $(WHATSNEW
	$(LI Added $(B -man) switch to browse manual.)
	$(LI Added $(B -lib) switch to generate library files.
	 Also causes multiple object files to be generated from one
	 source module.)
	$(LI When generating an executable file, only one object file
	 is now generated containing all the modules that were compiled, rather
	 than one object file per module.)
	$(LI Rewrote the $(LINK2 rdmd.html,$(B rdmd)) utility to properly track
	 dependencies and command-line compiler options (currently only working
	 under Linux).)
	$(LI Changed the Phobos makefile $(D linux.mak) to take advantage of
	 the new $(B -lib) feature. Improved full build speed by 3x.)
	$(LI std.algorithm: Changed the map() function so that it deduces the return type. Also map can be now curried.)
	$(LI std.contracts: Added file and line information to enforce. Added errnoEnforce that formats the error message according to errno. Added corresponding ErrnoException class.)
	$(LI std.conv: Made std.to curryable. Changed std.to to throw exception when object-to-object cast fails. Eliminated some superfluous printfs.)
	$(LI std.encoding: Added new functions encodedLength(dchar) and encode(dchar, ref E[]))
	$(LI std.encoding: Got rid of types Utf8, Utf16, Utf32, Ascii, Latin1, Windows1252. Introduced types AsciiChar, AsciiString, Latin1Char, Latin1String, Windows1252Char, Windows1252String.)
	$(LI std.encoding: For now commented out std.encoding.to.)
	$(LI std.file: Changed Boolean function signatures (e.g. exists) to return bool instead of int. Got rid of some gotos. Added the readText, lastModified, mkdirRecurse, and rmdirRecurse functions.)
	$(LI std.functional: Improved compose so it accepts an unbounded number of functions. Added the pipe function.)
	$(LI std.getopt: Added new option stopOnFirstNonOption. Also automatically expand dubious option groups with embedded spaces in them (useful for shebang scripts))
	$(LI std.math: improved integral powers)
	$(LI std.md5: Improved signature of sum so it takes multiple arrays. Added getDigestString.)
	$(LI std.path: changed signatures of test functions from bool to int. Implemented rel2abs for Windows. Improved join so that it accepts multiple paths. Got rid of some gotos with the help of scope statements.)
	$(LI std.process: added getenv and setenv. Improved system() so it returns the exit code correctly on Linux.)
	$(LI std.random: added the dice function - a handy (possibly biased) dice.)
	$(LI std.typecons: Finalized and documented the stupendous Rebindable template.)
	$(LI std.utf: added the codeLength function. Got rid of some gotos.)
    )
    $(BUGSFIXED
	$(LI std.format: Fixed unlisted bug in raw write for arrays)
	$(LI std.getopt: Fixed unlisted bug in dealing with one-letter options with bundling disabled)
	$(LI $(BUGZILLA 2014): fopen fails on large files.)
	$(LI $(BUGZILLA 2031): Documentation: template value parameters)
	$(LI $(BUGZILLA 2032): Documentation for creating a class on the stack is unintuitive)
	$(LI $(BUGZILLA 2037): Article on hijacking is outdated)
	$(LI $(BUGZILLA 2038): Remove hello2.html from samples directory)
	$(LI $(BUGZILLA 2039): -ignore switch is missing from compiler docs)
	$(LI $(BUGZILLA 2054): Const system broken on struct assignment.)
	$(LI $(BUGZILLA 2055): (ICE) Compiler crash on struct initializer with too many elements)
	$(LI $(BUGZILLA 2056): Const system does not allow certain safe casts/conversions involving deep composite types)
	$(LI $(BUGZILLA 2058): Describe hidden value passed to class member functions)
	$(LI $(BUGZILLA 2063): std.xml access violation for nested, closed tags)
	$(LI $(BUGZILLA 2065): Return value of std.file.exists() is inverted.)
	$(LI $(BUGZILLA 2067): call from anonymous class makes access violation.)
	$(LI $(BUGZILLA 2071): spec doesn't mention pointer arithmetic with two pointer operands)
	$(LI $(BUGZILLA 2072): std.typecons documentation anomaly.)
	$(LI $(BUGZILLA 2074): Variant arithmetic operations fail. For now the fix is to comment out all right-hand side operators. Suggestions for a better fix are welcome.)
	$(LI $(BUGZILLA 2075): Spec does not specify how array literals are stored.)
	$(LI $(BUGZILLA 2084): operator ?: does not compute the tightest type)
	$(LI $(BUGZILLA 2086): Describe relationship between string and char[] more explicitly)
	$(LI $(BUGZILLA 2089): Issues with CTFE and tuple indexes)
	$(LI $(BUGZILLA 2090): Cannot alias a tuple member which is a template instance)
	$(LI $(BUGZILLA 2100): Assertion failure: '0' on line 4842 in file 'expression.c')
	$(LI $(BUGZILLA 2109): asm {lea EAX, [0*0+EAX]; }  rejected.)
    )
)

$(VERSION 013, Apr 22, 2008, =================================================,

    $(WHATSNEW
	$(LI Added $(B -ignore) switch to ignore unsupported pragmas.)
	$(LI Unsupported pragmas now printed out with $(B -v) switch.)
	$(LI Added $(LINK2 operatoroverloading.html#Dot, opDot), which is
	 $(RED experimental only).)
	$(LI $(LINK2 statement.html#SwitchStatement, $(I SwitchStatement))s
	 can now accept
	 runtime initialized const and invariant case statements.)
	$(LI Changed $(CODE __FILE__) and $(CODE __LINE__) so they work as
	 parameter default initializers.)
	$(LI Incorporated Benjamin Shropshire's doc changes)
	$(LI Hidden methods now get a compile time warning rather than a runtime
	 one.)
	$(LI $(LINK2 html.html, Html source files) are now deprecated.)
	$(LI Added $(LINK2 function.html#pure-functions, pure) and
	 $(LINK2 function.html#nothrow-functions, nothrow) function attributes,
	 although their semantics are not implemented.)
	$(LI Deprecated $(I VolatileStatement); use
	 $(LINK2 statement.html#SynchronizedStatement, $(I SynchronizedStatement)) instead.)
	$(LI Added $(B __thread) storage class for thread local storage.
	 This is $(RED for testing purposes only) to check out the machinery
	 in the back end. The front end design of this will change.)
	$(LI $(LINK2 http://www.digitalmars.com/ctg/obj2asm.html, $(B obj2asm))
	 and $(LINK2 http://www.digitalmars.com/ctg/dumpobj.html, $(B dumpobj))
	 now better handle special ELF fixup records.)
	$(LI Added $(LINK2 function.html#partial-ordering, partial ordering)
	 rules to disambiguate function overloading.)
	$(LI std.perf: Bill Baxter cleaned it up.)
	$(LI std.xml.Document constructor now creates whole DOM tree.)
	$(LI Added std.encoding.)
    )
    $(BUGSFIXED
	$(LI $(NG_digitalmars_D 69085): const/invariant bug?)
	$(LI $(BUGZILLA 1712): vtbl[0] for interface not set to corresponding Interface*)
	$(LI $(BUGZILLA 1723): __traits(getVirtualFunctions) on a non-function fails badly)
	$(LI $(BUGZILLA 1741): crash on associative array with static array as index type)
	$(LI $(BUGZILLA 1905): foreach docs inconsistency)
	$(LI $(BUGZILLA 1906): foreach cannot use index with large arrays)
	$(LI $(BUGZILLA 1925))
	$(LI $(BUGZILLA 1935): The std.recls samples in the DMD .zip are obsolete.)
	$(LI $(BUGZILLA 1967): getDirName does not seem to use altsep on windows)
	$(LI $(BUGZILLA 1978): Wrong vtable call)
	$(LI $(BUGZILLA 1991): Dmd hangs)
	$(LI $(BUGZILLA 2016): 'invariant' TypeSpecialization is missing)
	$(LI $(BUGZILLA 2019): Appending a one-element array literal doesn't work)
    )
)

$(VERSION 012, Mar 6, 2008, =================================================,

    $(WHATSNEW
	$(LI Added predefined version($(LINK2 version.html#PredefinedVersions, unittest)). See $(BUGZILLA 458))
	$(LI Removed $(B std.math2))
	$(LI Added compile time error for comparing class types against $(CODE null).)
	$(LI Added struct destructors and postblits.)

	$(LI std.algorithm: Made some imports conditional for the Unittest
	version; fixed doc typo; made min and max always return the tightest
	type and work with mixes of signed and unsigned; changed enum value
	names to obey lowercase convention; changed OrderStrategy to
	SwapStrategy as it's not just for ordering (e.g. see eliminate).)

	$(LI std.bitmanip: simplified code generated for bitfields and improved
	error message.)

	$(LI std.format: ate dogfood: used bitfields internally.)

	$(LI std.functional: fixed binaryfun to work with constant-size arrays;
	added compose.)

	$(LI std.random: made unpredictableSeed return different numbers every
	call (except for rarely-encountered MT scenarios); added private
	variable name that will take experts millenia to figure out; changed the
	boundaries syntax from two separate characters '[', '$(LPAREN)' to one
	string "[$(LPAREN)" throughout.)

	$(LI std.traits: added mostNegative, mostly to assuage for the
	unpardonable mistake of inheriting C++'s unpardonable mistake of
	defining "min" to mean very different things for floating-point types
	and integral types.)

	$(LI std.typecons: added undocumented Rebindable in preparation for
	opImplicitCast.)

	$(LI std.math:
	$(UL
	$(LI Support for different CPU IEEE 'real' formats: 64-bit, 80-bit and
	128-bit (quadruple) reals, both BigEndian and LittleEndian; partial
	support for non-IEEE 'doubledouble' reals.)
	$(LI Added implementation of nextafter $(BUGZILLA 1722) and scalb for
	DMD-Windows.)
	$(LI Added nextUp(), nextDown())
	$(LI $(BUGZILLA 1881): feqrel nonsensical for non-real arguments.)
	$(LI internal functions isPosZero(), isNegZero() removed in favour of
	the more generally useful isIdentical().)
	$(LI asm versions of functions which were not implemented by DMD
	Windows:  scalb, lrint.)
	$(LI added creal expi(real y) which is useful for simultaneous
	calculation of sin + cos.)
	)
	)
    )
    $(BUGSFIXED
	$(LI std.contracts: fixed unlisted bug in pointsTo.)
	$(LI std.conv: fixed bug related to number-to-number conversion (T.min
	hits again).)
	$(LI Fixed dwarf bug with DT_AT_upper_bound)
	$(LI $(BUGZILLA 756): IFTI for tuples only works if tuple parameter is last)
	$(LI $(BUGZILLA 1454): IFTI cant  deduce parameter if alias argument used)
	$(LI $(BUGZILLA 1661): Not possible to specialize on template with integer parameter)
	$(LI $(BUGZILLA 1800): Compiler crash on enums nested in structs)
	$(LI $(BUGZILLA 1801): Const structs should be assignable to non-const variables unless they contain references)
	$(LI $(BUGZILLA 1806): "const" makes typesafe variadic arguments not work properly.)
	$(LI $(BUGZILLA 1809): template.c:2600)
	$(LI $(BUGZILLA 1810): MmFile anonymous mapping does not work under win32)
	$(LI $(BUGZILLA 1819): spurious warning about missing return statement after synchronized)
	$(LI $(BUGZILLA 1821): ICE when using __traits isSame on const/invariant variables)
	$(LI $(BUGZILLA 1823): Implicit conversion to const on associative array)
	$(LI $(BUGZILLA 1828): Several Thread Issues)
	$(LI $(BUGZILLA 1833): std.c.windows.windows should use enums for constants, or be more selective about use of extern(Windows))
	$(LI $(BUGZILLA 1836): Inline assembler can't use enum values as parameters.)
	$(LI $(BUGZILLA 1837): Make dmd stop flooding the console: prints content of passed parameter file)
	$(LI $(BUGZILLA 1843): Bogus unreachable statement on forward referenced struct, lacks line number)
	$(LI $(BUGZILLA 1850): The compiler accepts lower case asm registers.)
	$(LI $(BUGZILLA 1851): missing opCall? when cast away const struct)
	$(LI $(BUGZILLA 1852): you get opCall missing when cast to a struct(diagnostic))
	$(LI $(BUGZILLA 1853): opCmp documentation really needs some examples)
	$(LI $(BUGZILLA 1854): bug in new flow analysis (warnings on valid code))
	$(LI $(BUGZILLA 1857): Runtime segfault while profileing - jump to invalid code address)
	$(LI $(BUGZILLA 1862): asm: [ESI+1*EAX] should be a legal addr mode)
	$(LI $(BUGZILLA 1865): Escape sequences are flawed.)
	$(LI $(BUGZILLA 1867): lazy adds spurious const qualifier)
	$(LI $(BUGZILLA 1871): DMD debug messages printed)
	$(LI $(BUGZILLA 1873): structs with at least one immutable member are completely immutable)
	$(LI $(BUGZILLA 1874): __traits(allMembers, T) fails to list methods which only have non-mutating overloads)
	$(LI $(BUGZILLA 1876): inside a non-static class method, should "&(     f)" be same as "&(this.f)" ?)
	$(LI $(BUGZILLA 1877): Errors in the documentation of std.math.atan2)
	$(LI $(BUGZILLA 1882): Internal error: ..\ztc\cod1.c 2529)
	$(LI $(BUGZILLA 1883): templates instantiated as real gives incorrect values)
	$(LI $(BUGZILLA 1884): manifest constants for strings)
	$(LI $(BUGZILLA 1885): Syntax error for object identity test between invariant/mutable references)
	$(LI $(BUGZILLA 1887): compiler freeze on array of dyn. arrays with empty first initializer)
    )
)

$(VERSION 011, Feb 18, 2008, =================================================,

    $(WHATSNEW
	$(LI std.typecons: fixed code bloat issue; added Tuple.toString; added function tuple(); fixed unlisted bug in enumValuesImpl.)
	$(LI std.process: added function shell().)
	$(LI std.math: minor change in approxEqual.)
	$(LI std.contracts: added functions pointsTo())
	$(LI std.numeric: minor unittest fixes.)
	$(LI std.bitmanip: fixed code bloat issue, reintroduced FloatRep and DoubleRep.)
	$(LI std.conv: minor simplification of implementation.)
	$(LI std.regexp: added reference to ECMA standard in the documentation.)
	$(LI std.getopt: changed return type from bool to void, error is signaled by use of exceptions.)
	$(LI std.functional: added unaryFun, binaryFun, adjoin.)
	$(LI std.string: updated documentation, changed code to compile with warnings enabled.)
	$(LI std.traits: changed FieldTypeTuple; added RepresentationTypeTuple, hasAliasing; fixed bug 1826; added call to flush() from within write; fixed unlisted bug in lines().)
	$(LI std.algorithm: added map, reduce, filter, inPlace, move, swap, overwriteAdjacent, find, findRange, findBoyerMoore, findAdjacent, findAmong, findAmongSorted, canFind, canFindAmong, canFindAmongSorted, count, equal, overlap, min, max, mismatch, EditOp, none, substitute, insert, remove, levenshteinDistance, levenshteinDistanceAndPath, copy, copyIf, iterSwap, swapRanges, reverse, rotate, SwapStrategy, Unstable, Semistable, Stable, eliminate, partition, nthElement, sort, schwartzSort, partialSort, isSorted, makeIndex, schwartzMakeIndex, lowerBound, upperBound, equalRange, canFindSorted.)
	$(LI std.thread: fixed so it compiles with warnings enabled.)
	$(LI std.file: made getSize() faster under Linux.)
	$(LI std.random: fixed so it compiles with warnings enabled; improved function uniform so it deduces type generated from its arguments.)
	$(LI std.format: added fixes to make formatting work with const data.)
	$(LI std.path: minor documentation changes. )
	$(LI Added $(CODE std.xml))
	$(LI Added $(CODE std.complex))
	$(LI Added $(CODE std.iterator))
	$(LI Added $(CODE std.c.linux.tipc))
	$(LI Added $(CODE std.c.linux.termios))
	$(LI Added $(CODE nothrow) keyword)
	$(LI Re-enabled auto interfaces.)
	$(LI Now allow static arrays to be lvalues.)
	$(LI Now allows implicit casting of $(CODE null) to/from const/invariant.)
	$(LI Now allows implicit casting of $(I StructLiteral)s if each of
	 its arguments can be implicitly cast.)
	$(LI Now allows implicit casting of structs to/from const/invariant if
	 each of its fields can be.)
	$(LI Added $(LINK2 pragma.html#Predefined-Pragmas, pragma startaddress).)
	$(LI $(CODE .tupleof) can now access private fields of a struct/class)
	$(LI Enhancement $(BUGZILLA 493): Partial IFTI does not work)
    )

    $(BUGSFIXED
	$(LI Fixed $(NG_digitalmars_D 66406) Remaining const niggles #1 - Custom POD types)
	$(LI Fixed display of ddoc template parameters that were aliased)
	$(LI Fixed bug in std.file.readln() for Windows in translated mode)
	$(LI $(BUGZILLA 1072): CTFE: crash on for loop with blank increment)
	$(LI $(BUGZILLA 1435): DDoc: Don't apply DDOC_PSYMBOL everywhere)
	$(LI $(BUGZILLA 1815): foreach with interval does not increment pointers correctly)
	$(LI $(BUGZILLA 1825): local instantiation and function nesting)
	$(LI $(BUGZILLA 1837): Make dmd stop flooding the console: prints content of passed parameter file)
	$(LI $(BUGZILLA 1842): Useless linker command line output during compilation on Linux)
    )
)

$(VERSION 010, Jan 20, 2008, =================================================,

    $(WHATSNEW
	$(LI $(CODE opAssign) can no longer be overloaded for class objects.)
	$(LI $(CODE WinMain) and $(CODE DllMain) can now be in template mixins.)
	$(LI Added $(CODE pure) keyword.)
    )

    $(BUGSFIXED
	$(LI $(BUGZILLA 1319): compiler crashes with functions that take const ref arguments)
	$(LI $(BUGZILLA 1697): Internal error: ..\ztc\cgcod.c 2322 with -O)
	$(LI $(BUGZILLA 1700): ICE attempting to modify member of const return struct)
	$(LI $(BUGZILLA 1707): '==' in TemplateParameterList in IsExpression causes segfault)
	$(LI $(BUGZILLA 1711): typeof with delegate literal not allowed as template parameter)
	$(LI $(BUGZILLA 1713): foreach index with tuples and templates fails)
	$(LI $(BUGZILLA 1718): obscure exit with error code 5)
	$(LI $(BUGZILLA 1719): Compiler crash or unstable code generation with scoped interface instances)
	$(LI $(BUGZILLA 1720): std.math.NotImplemented missing a space in message)
	$(LI $(BUGZILLA 1724): Internal error: toir.c 177)
	$(LI $(BUGZILLA 1725): std.stream.BufferedFile.create should use FileMode.OutNew)
	$(LI $(BUGZILLA 1757): there is an fault  in phobos windows api interface)
	$(LI $(BUGZILLA 1762): Wrong name mangling for pointer args of free extern (C++) functions)
	$(LI $(BUGZILLA 1767): rejects-valid, diagnostic)
	$(LI $(BUGZILLA 1769): Typo on the page about exceptions)
	$(LI $(BUGZILLA 1773): excessively long integer literal)
	$(LI $(BUGZILLA 1779): Compiler crash when deducing more than 2 type args)
	$(LI $(BUGZILLA 1783): DMD 1.025 asserts on code with struct, template, and alias)
	$(LI $(BUGZILLA 1788): dmd segfaults without info)
	$(LI $(NG_digitalmars_D_announce 11066): Re: DMD 1.025 and 2.009 releases)
    )
)

$(VERSION 009, Jan 1, 2008, =================================================,

$(WHATSNEW
	$(LI Redid const/invariant semantics again.)
	$(LI Extended enums to allow declaration of manifest constants.)
)

$(BUGSFIXED
	$(LI $(BUGZILLA 1111): enum value referred to by another value of same enum is considered as enum's base type, not enum type)
	$(LI $(BUGZILLA 1694): Zip::ArchiveMember::name format bug)
	$(LI $(BUGZILLA 1702): ICE when identifier is undefined)
	$(LI $(BUGZILLA 1738): Error on struct without line number)
	$(LI $(BUGZILLA 1742): CTFE fails on some template functions)
	$(LI $(BUGZILLA 1743): interpret.c:1421 assertion failure on CTFE code)
	$(LI $(BUGZILLA 1744): CTFE: crash on assigning void-returning function to variable)
	$(LI $(BUGZILLA 1745): Internal error: ..\ztc\out.c 115)
	$(LI $(BUGZILLA 1749): std.socket not thread-safe due to strerror)
	$(LI $(BUGZILLA 1753): String corruption in recursive CTFE functions)
	$(LI $(NG_digitalmars_D 63456): Cannot overload on constancy of this)
)
)

$(VERSION 008, Nov 27, 2007, =================================================,

$(WHATSNEW
	$(LI std.string: Made munch more general and added function chompPrefix.)
	$(LI std.variant: Added documentation for variantArray)
	$(LI std.traits: Added CommonType template, fixed isStaticArray.)
	$(LI std.bitarray: scheduled for deprecation)
	$(LI std.bitmanip: new module with the content of std.bitarray plus the bitfields, FloatRep, and DoubleRep templates)
	$(LI std.process: Made getpid visible in Linux builds)
	$(LI std.math: Made nextafter visible for all floating types. Added approxEqual template.)
	$(LI std.contracts: Added enforce signature taking an exception)
	$(LI std.conv: Made conv_error a template parameterized on the types being converted.)
	$(LI std.stdio: Cosmetic changes.)
	$(LI std.system: Cosmetic changes.)
	$(LI std.file: Fixed bug in function dirEntries.)
	$(LI std.random: Major addition of engines and distributions.)
	$(LI std.format: Added raw ('r') format specifier for writef*.)
	$(LI std.path: Added rel2abs (Linux version only).)
	$(LI std.algorithm: new module)
	$(LI std.typecons: new module)
	$(LI std.functional: new module)
	$(LI std.numeric: new module)
	$(LI Added $(LINK2 struct.html#ConstStruct, const/invariant structs),
	 $(LINK2 class.html#ConstClass, classes) and
	 $(LINK2 interface.html#ConstInterface, interfaces).)
	$(LI Added $(CODE const) and $(CODE invariant) to $(LINK2 expression.html#IsExpression, IsExpression)s.)
	$(LI Added $(CODE typeof(return)) type specifier.)
	$(LI Changed the way coverage analysis is done so it is independent
	 of order dependencies among modules.)
	$(LI Revamped const/invariant.)
)

$(BUGSFIXED
	$(LI $(BUGZILLA 70): valgrind: Conditional jump or move depends on uninitialised value(s) in elf_findstr)
	$(LI $(BUGZILLA 71): valgrind: Invalid read of size 4 in elf_renumbersyms)
	$(LI $(BUGZILLA 204): Error message on attempting to instantiate an abstract class needs to be improved)
	$(LI $(BUGZILLA 1508): dmd/linux template symbol issues)
	$(LI $(BUGZILLA 1651): .di file generated with -H switch does not translate function() arguments correctly)
	$(LI $(BUGZILLA 1655): Internal error: ..\ztc\cgcod.c 1817)
	$(LI $(BUGZILLA 1656): illegal declaration accepted)
	$(LI $(BUGZILLA 1664): (1.23).stringof  generates bad code)
	$(LI $(BUGZILLA 1665): Internal error: ..\ztc\cod2.c 411)
)
)

$(VERSION 007, Oct 31, 2007, =================================================,

$(WHATSNEW
	$(LI Functors now supported by std.traits.ReturnType().)
	$(LI Transitive const now leaves invariants intact in the tail.)
	$(LI Added overloadable unary * operation as opStar().)
	$(LI Full closure support added.)
	$(LI Data items in static data segment &gt;= 16 bytes in size
	are now paragraph aligned.)
)

$(BUGSFIXED
	$(LI Variables of type void[0] can now be declared.)
	$(LI Static multidimensional arrays can now be initialized with
	other matching static multidimensional arrays.)
	$(LI $(BUGZILLA 318): wait does not release thread resources on Linux)
	$(LI $(BUGZILLA 322): Spawning threads which allocate and free memory leads to pause error on collect)
	$(LI $(BUGZILLA 645): Race condition in std.thread.Thread.pauseAll)
	$(LI $(BUGZILLA 689): Clean up the spec printfs!)
	$(LI $(BUGZILLA 697): No const folding on asm db,dw, etc)
	$(LI $(BUGZILLA 706): incorrect type deduction for array literals in functions)
	$(LI $(BUGZILLA 708): inline assembler: "CVTPS2PI mm, xmm/m128" fails to compile)
	$(LI $(BUGZILLA 709): inline assembler: "CVTPD2PI mm, xmm/m128" fails to compile)
	$(LI $(BUGZILLA 718): Internal error: ../ztc/cgcod.c 562)
	$(LI $(BUGZILLA 723): bad mixin of class definitions at function level: func.c:535: virtual void FuncDeclaration::semantic3(Scope*): Assertion `0` failed)
	$(LI $(BUGZILLA 725): expression.c:6516: virtual Expression* MinAssignExp::semantic(Scope*): Assertion `e2->type->isfloating()` failed.)
	$(LI $(BUGZILLA 726): incorrect error line for "override" mixin)
	$(LI $(BUGZILLA 729): scope(...) statement in SwitchBody causes compiler to segfault)
	$(LI $(BUGZILLA 1258): Garbage collector loses memory upon array concatenation)
	$(LI $(BUGZILLA 1480): std.stream throws the new override warning all over the place)
	$(LI $(BUGZILLA 1483): Errors in threads not directed to stderr)
	$(LI $(BUGZILLA 1557): std.zlib allocates void[]s instead of ubyte[]s, causing leaks.)
	$(LI $(BUGZILLA 1580): concatenating invariant based strings should work)
	$(LI $(BUGZILLA 1593): ICE compiler crash empty return statement in function)
	$(LI $(BUGZILLA 1613): DMD hangs on syntax error)
	$(LI $(BUGZILLA 1618): Typo in std\system.d)
)
)

$(VERSION 006, Oct 16, 2007, =================================================,

$(WHATSNEW
	$(LI $(RED Transformed all of $(CODE string), $(CODE wstring),
	and $(CODE dstring) into invariant definitions).
	Tons of changes in function signatures and
	implementations rippled through the standard library.
	Initial experience
	with invariant strings seems to be highly encouraging.)
	$(LI Implemented $(LINK2 function.html#overload-sets, Overload Sets) for functions and templates.)
	$(LI Added the $(LINK2 phobos/std_getopt.html,std.getopt) module that makes standards-conforming command-line processing easy.)
	$(LI Added the parse and assumeUnique to the $(LINK2 phobos/std_conv.html, std.conv) module.)
	$(LI Added the dirEntries function to the $(LINK2 phobos/std_file.html, std.file) module.)
	$(LI Added the basename and dirname functions (which alias the less gainful names getBaseName and getDirectoryName to the $(LINK2 phobos/std_path.html,std.path) module.))
	$(LI Added optional terminator to readln; added the convenience functions fopen and popen; added functions lines and chunks; all to the $(LINK2 phobos/std_stdio.html, std.stdio) module.)
	$(LI Added the munch function to the $(LINK2 phobos/std_string.html, std.string) module.)
	$(LI Fixed isStaticArray; added BaseClassesTuple, TransitiveBaseTypeTuple, ImplicitConversionTargets, isIntegral, isFloatingPoint, isNumeric, isSomeString, isAssociativeArray, isDynamicArray, isArray; all to the $(LINK2 phobos/std_traits.html, std.traits) module.)
	$(LI Added the $(LINK2 phobos/std_variant.html, std.variant) module.)
	$(LI Incorporated many of the Tango GC structural differences (much more to go still).)
	$(LI Added the $(LINK2 phobos/std_contracts.html, std.contracts) module.)
	$(LI Breaking change: $(CODE std.stdio.writef) can now only accept a format as
	its first argument.)
)

$(BUGSFIXED
   $(LI $(BUGZILLA 1478): Avoid libc network api threadsafety issues)
   $(LI $(BUGZILLA 1491): Suppress SIGPIPE when sending to a dead socket)
   $(LI $(BUGZILLA 1562): Deduction of template alias parameter fails)
   $(LI $(BUGZILLA 1571): Const on function parameters not carried through to .di file)
   $(LI $(BUGZILLA 1575): Cannot do assignment of tuples)
   $(LI $(BUGZILLA 1579): write[ln] fails for obj.toString())
   $(LI $(BUGZILLA 1580): Concatenating invariant based strings should work)
)
)

$(VERSION 005, Oct 1, 2007, =================================================,

$(WHATSNEW
	$(LI $(D std.math.sin), $(D cos), $(D tan) are now evaluated at
	compile time if the argument is a constant.)
	$(LI Added Cristian Vlasceanu's idea for
	$(LINK2 cpp_interface.html, C++ interface) for 'plugins')
	$(LI Overhaul phobos $(D linux.mak) and add documentation build logic)
	$(LI Massive additions to $(LINK2 phobos/std_conv.html, std.conv))
	$(LI Add $(CODE writeln()) and $(CODE write()) to $(LINK2 phobos/std_stdio.html, std.stdio))
)

$(BUGSFIXED
	$(LI Fix std.boxer boxing of Object's (unit test failure))
	$(LI Fix std.demangle to not show hidden parameters (this and delegate context pointers))
	$(LI $(BUGZILLA 217): typeof not working properly in internal/object.d)
	$(LI $(BUGZILLA 218): Clean up old code for packed bit array support)
	$(LI $(BUGZILLA 223): Error message for unset constants doesn't specify error location)
	$(LI $(BUGZILLA 278): dmd.conf search path doesn't work)
	$(LI $(BUGZILLA 479): can't compare arrayliteral statically with string)
	$(LI $(BUGZILLA 549): A class derived from a deprecated class is not caught)
	$(LI $(BUGZILLA 550): Shifting by more bits than size of quantity is allowed)
	$(LI $(BUGZILLA 551): Modulo operator works with imaginary and complex operands)
	$(LI $(BUGZILLA 556): is (Type Identifier : TypeSpecialization) doesn't work as it should)
	$(LI $(BUGZILLA 668): Use of *.di files breaks the order of static module construction)
	$(LI $(BUGZILLA 1125): Segfault using tuple in asm code, when size not specified)
	$(LI $(BUGZILLA 1437): dmd crash: "Internal error: ..\ztc\cod4.c 357")
	$(LI $(BUGZILLA 1456): Cannot use a constant with alias template parameters)
	$(LI $(BUGZILLA 1474): regression: const struct with an initializer not recognized as a valid alias template param)
	$(LI $(BUGZILLA 1488): Bad code generation when using tuple from asm)
	$(LI $(BUGZILLA 1510): ICE: Assertion failure: 'ad' on line 925 in file 'func.c')
	$(LI $(BUGZILLA 1523): struct literals not work with typedef)
	$(LI $(BUGZILLA 1530): Aliasing problem in DMD front end code)
	$(LI $(BUGZILLA 1531): cannot access typedef'd class field)
	$(LI $(BUGZILLA 1537): Internal error: ..\ztc\cgcod.c 1521)
)
)

$(VERSION 004, Sep 5, 2007, =================================================,

$(WHATSNEW
	$(LI Added command line switches $(B -defaultlib) and $(B -debuglib))
	$(LI $(BUGZILLA 1445): Add default library options to sc.ini / dmd.conf)
	$(LI Changed result type of IsExpression from int to bool.)
	$(LI Added $(B isSame) and $(B compiles) to $(B __traits).)
	$(LI Added optional $(I TemplateParameterList) to $(I IsExpression).)
	$(LI Added warning when $(B override) is omitted.)
	$(LI Added $(B std.hiddenfunc).)
	$(LI Added trace_term() to object.d to fix $(BUGZILLA 971): No profiling output is generated if the application terminates with exit)
	$(LI Multiple module static constructors/destructors allowed.)
	$(LI Added new syntax for string literals (delimited, heredoc, D tokens))
	$(LI Added __EOF__ token)
)

$(BUGSFIXED
	$(LI Fixed $(NG_digitalmars_D 56414))
	$(LI $(BUGZILLA 961): std.windows.registry stack corruption)
	$(LI $(BUGZILLA 1315): CTFE doesn't default initialise arrays of structs)
	$(LI $(BUGZILLA 1342): struct const not accepted as initializer for another struct)
	$(LI $(BUGZILLA 1363): Compile-time issue with structs in 'for')
	$(LI $(BUGZILLA 1375): CTFE fails for null arrays)
	$(LI $(BUGZILLA 1378): A function call in an array literal causes compiler to crash)
	$(LI $(BUGZILLA 1384): Compiler segfaults when using struct variable like a function with no opCall member.)
	$(LI $(BUGZILLA 1388): multiple static constructors allowed in module)
	$(LI $(BUGZILLA 1414): compiler crashes with CTFE and structs)
	$(LI $(BUGZILLA 1421): Stack Overflow when using __traits(allMembers...))
	$(LI $(BUGZILLA 1423): Registry: corrupted value)
	$(LI $(BUGZILLA 1436): std.date.getLocalTZA() returns wrong values when in DST under Windows)
	$(LI $(BUGZILLA 1446): Missing comma in Final Const and Invariant page title)
	$(LI $(BUGZILLA 1447): CTFE does not work for static member functions of a class)
	$(LI $(BUGZILLA 1448): UTF-8 output to console is seriously broken)
	$(LI $(BUGZILLA 1450): Registry: invalid UTF-8 sequence)
	$(LI $(BUGZILLA 1460): Compiler crash on valid code)
	$(LI $(BUGZILLA 1464): "static" foreach breaks CTFE)
	$(LI $(BUGZILLA 1468): A bug about stack overflow.)
)
)

$(VERSION 003, Jul 21, 2007, =================================================,

$(WHATSNEW
	$(LI Added 0x78 Codeview extension for type $(B dchar).)
	$(LI Moved $(B next) member from $(B Object.Error) to $(B Object.Exception))
	$(LI Added $(LINK2 statement.html#ForeachRangeStatement, ForeachRangeStatement)).
	$(LI Added $(B extern (System)))
	$(LI Added $(LINK2 traits.html, std.traits))
	$(LI $(BUGZILLA 345): updated std.uni.isUniAlpha to Unicode 5.0.0)
)

$(BUGSFIXED
	$(LI $(BUGZILLA 46): Included man files should be updated)
	$(LI $(BUGZILLA 268): Bug with SocketSet and classes)
	$(LI $(BUGZILLA 406): std.loader is broken on linux)
	$(LI $(BUGZILLA 561): Incorrect duplicate error message when trying to create instance of interface)
	$(LI $(BUGZILLA 588): lazy argument and nested symbol support to std.demangle)
	$(LI $(BUGZILLA 668): Use of *.di files breaks the order of static module construction)
	$(LI $(BUGZILLA 1110): std.format.doFormat + struct without toString() == crash)
	$(LI $(BUGZILLA 1300): Issues with struct in compile-time function)
	$(LI $(BUGZILLA 1306): extern (Windows) should work like extern (C) for variables)
	$(LI $(BUGZILLA 1318): scope + ref/out parameters are allowed, contrary to spec)
	$(LI $(BUGZILLA 1320): Attributes spec uses 1.0 const semantics in 2.0 section)
	$(LI $(BUGZILLA 1331): header file genaration generates a ":" instead of ";" at pragma)
	$(LI $(BUGZILLA 1332): Internal error: ../ztc/cod4.c 357)
	$(LI $(BUGZILLA 1333): -inline ICE: passing an array element to an inner class's constructor in a nested function, all in a class or struct)
	$(LI $(BUGZILLA 1336): Internal error when trying to construct a class declared within a unittest from a templated class.)
)
)

$(VERSION 002, Jul 1, 2007, =================================================,

$(WHATSNEW
	$(LI Renamed linux library from $(B libphobos.a) to $(B libphobos2.a))
)

$(BUGSFIXED
	$(LI $(BUGZILLA 540): Nested template member function error - "function expected before ()")
	$(LI $(BUGZILLA 559): Final has no effect on methods)
	$(LI $(BUGZILLA 627): Concatenation of strings to string arrays with ~ corrupts data)
	$(LI $(BUGZILLA 629): Misleading error message "Can only append to dynamic arrays")
	$(LI $(BUGZILLA 639): Escaped tuple parameter ICEs dmd)
	$(LI $(BUGZILLA 641): Complex string operations in template argument ICEs dmd)
	$(LI $(BUGZILLA 657): version(): ignored)
	$(LI $(BUGZILLA 689): Clean up the spec printfs!)
	$(LI $(BUGZILLA 1103): metastrings.ToString fails for long &gt; 0xFFFF_FFFF)
	$(LI $(BUGZILLA 1107): CodeView: wrong CV type for bool)

	$(LI $(BUGZILLA 1118): weird switch statement behaviour)
	$(LI $(BUGZILLA 1186): Bind needs a small fix)
	$(LI $(BUGZILLA 1199): Strange error messages when indexing empty arrays or strings at compile time)
	$(LI $(BUGZILLA 1200): DMD crash: some statements containing only a ConditionalStatement with a false condition)
	$(LI $(BUGZILLA 1203): Cannot create Anonclass in loop)
	$(LI $(BUGZILLA 1204): segfault using struct in CTFE)
	$(LI $(BUGZILLA 1206): Compiler hangs on this() after method in class that forward references struct)
	$(LI $(BUGZILLA 1207): Documentation on destructors is confusing)
	$(LI $(BUGZILLA 1211): mixin("__LINE__") gives incorrect value)
	$(LI $(BUGZILLA 1212): dmd generates bad line info)

	$(LI $(BUGZILLA 1216): Concatenation gives 'non-constant expression' outside CTFE)
	$(LI $(BUGZILLA 1217): Dollar ($) seen as non-constant expression in non-char[] array)
	$(LI $(BUGZILLA 1219): long.max.stringof gets corrupted)
	$(LI $(BUGZILLA 1224): Compilation does not stop on asserts during CTFE)
	$(LI $(BUGZILLA 1228): Class invariants should not be called before the object is fully constructed)
	$(LI $(BUGZILLA 1233): std.string.ifind(char[] s, char[] sub) fails on certain non ascii strings)
	$(LI $(BUGZILLA 1234): Occurrence is misspelled almost everywhere)
	$(LI $(BUGZILLA 1235): std.string.tolower() fails on certain utf8 characters)
	$(LI $(BUGZILLA 1236): Grammar for Floating Literals is incomplete)
	$(LI $(BUGZILLA 1239): ICE when empty tuple is passed to variadic template function)

	$(LI $(BUGZILLA 1242): DMD AV)
	$(LI $(BUGZILLA 1244): Type of array length is unspecified)
	$(LI $(BUGZILLA 1247): No time zone info for India)
	$(LI $(BUGZILLA 1285): Exception typedefs not distinguished by catch)
	$(LI $(BUGZILLA 1287): Iterating over an array of tuples causes "glue.c:710: virtual unsigned int Type::totym(): Assertion `0` failed.")
	$(LI $(BUGZILLA 1290): Two ICEs, both involving real, imaginary, ? : and +=.)
	$(LI $(BUGZILLA 1291): .stringof for a class type returned from a template doesn't work)
	$(LI $(BUGZILLA 1292): Template argument deduction doesn't work)
	$(LI $(BUGZILLA 1294): referencing fields in static arrays of structs passed as arguments generates invalid code)
	$(LI $(BUGZILLA 1295): Some minor errors in the lexer grammar)
)
)

$(VERSION 001, Jun 27, 2007, =================================================,

$(WHATSNEW
	$(LI Added $(B D_Version2) predefined identifier to indicate
	this is a D version 2.0 compiler)
	$(LI Added $(B __VENDOR__) and $(B __VERSION__).)
	$(LI Now an error to use both $(B const) and $(B invariant) as storage
	classes for the same declaration)
	$(LI The $(B .init) property for a variable is now based on its
	type, not its initializer.)
)

$(BUGSFIXED
	$(LI $(B std.compiler) now is automatically updated.)
	$(LI Fixed problem catting mutable to invariant arrays.)
	$(LI Fixed CFTE bug with e++ and e--.)
	$(LI $(BUGZILLA 1254): Using a parameter initialized to void in a compile-time evaluated function doesn't work)
	$(LI $(BUGZILLA 1256): "with" statement with symbol)
	$(LI $(BUGZILLA 1259): Inline build triggers an illegal error msg "Error: S() is not an lvalue")
	$(LI $(BUGZILLA 1260): Another tuple bug)
	$(LI $(BUGZILLA 1261): Regression from overzealous error message)
	$(LI $(BUGZILLA 1262): Local variable of struct type initialized by literal resets when compared to .init)
	$(LI $(BUGZILLA 1263): Template function overload fails when overloading on both template and non-template class)
	$(LI $(BUGZILLA 1268): Struct literals try to initialize static arrays of non-static structs incorrectly)
	$(LI $(BUGZILLA 1269): Compiler crash on assigning to an element of a void-initialized array in CTFE)
	$(LI $(BUGZILLA 1270): -inline produces an ICE)
	$(LI $(BUGZILLA 1272): problems with the new 1.0 section)
	$(LI $(BUGZILLA 1274): 2.0 beta link points to dmd.zip which is the 1.x chain)
	$(LI $(BUGZILLA 1275): ambiguity with 'in' meaning)
	$(LI $(BUGZILLA 1276): static assert message displayed with escaped characters)
	$(LI $(BUGZILLA 1277): "in final const scope" not considered redundant storage classes)
	$(LI $(BUGZILLA 1279): const/invariant functions don't accept const/invariant return types)
	$(LI $(BUGZILLA 1280): std.socket.Socket.send (void[],SocketFlags) should take a const(void)[] instead)
	$(LI $(BUGZILLA 1283): writefln: formatter applies to following variable)
	$(LI $(BUGZILLA 1286): crash on invariant struct member function referencing globals)
)
)

$(VERSION 000, Jun 17, 2007, =================================================,

$(WHATSNEW
	$(LI Added aliases $(B string), $(B wstring), and $(B dstring)
	for strings.)
	$(LI Added $(B .idup) property for arrays to create invariant
	copies.)
	$(LI Added const, invariant, and final.)
	$(LI $(B in) parameter storage class now means final scope const.)
	$(LI foreach value variables now default to final if not declared
	as inout.)
	$(LI class and struct invariant declarations now must have a ().)
)

$(BUGSFIXED
	$(LI Added missing \n to exception message going to stderr.)
	$(LI Fixed default struct initialization for CTFE.)
	$(LI $(BUGZILLA 1226): ICE on a struct literal)
)
)

)

Macros:
	TITLE=Change Log
	WIKI=ChangeLog

	NEW = $(LI Version <a href="#new2_$0">D 2.$0</a>)

	VERSION=
	<div class="version">
	$(B $(LARGE <a name="new2_$1">
	  Version
	  <a HREF="http://ftp.digitalmars.com/dmd.2.$1.zip" title="D 2.$1">D 2.$1</a>
	))
	$(SMALL $(I $2, $3))
	$5
	</div>

	BUGZILLA = <a href="https://issues.dlang.org/show_bug.cgi?id=$0">Bugzilla $0</a>
	CPPBUGZILLA = <a href="http://bugzilla.digitalmars.com/issues/show_bug.cgi?id=$0">Bugzilla $0</a>
	DSTRESS = dstress $0
	BUGSFIXED = <div class="bugsfixed">$(H4 Bugs Fixed) $(UL $0 )</div>
	DMDBUGSFIXED = <div class="bugsfixed">$(H4 DMD Bugs Fixed) $(UL $0 )</div>
	LIBBUGSFIXED = <div class="bugsfixed">$(H4 Library Bugs Fixed) $(UL $0 )</div>
	RUNTIMEBUGSFIXED = <div class="bugsfixed">$(H4 Druntime Bugs Fixed) $(UL $0 )</div>
    BUGSTITLE = <div class="bugsfixed">$(H4 $1) $(OL $2 )</div>

	UPCOMING = <div id="upcoming">$(H4 Under Construction) $(OL $0 )</div>
	WHATSNEW = <div id="whatsnew">$(H4 New/Changed Features) $(UL $0 )</div>
	NEWPHOBOS = <div id="whatsnew">$(H4 New/Changed Phobos) $(UL $0 )</div>
	LARGE=<font size=4>$0</font>
	TRENAME=$(TR $(TD $(CODE $1)) $(TD $(CODE $2)))
	LII= $(LI $(D $1) $(UL $+ ))

	WHATSNEW2=$(LINK2 https://issues.dlang.org/buglist.cgi?chfieldto=$2&query_format=advanced&chfield=resolution&chfieldfrom=$1&chfieldvalue=FIXED&bug_severity=enhancement&bug_status=RESOLVED&version=D2&version=D1%20%26%20D2&resolution=FIXED&product=D, New/Changed Features)
	DMDBUGSFIXED2=$(LINK2 https://issues.dlang.org/buglist.cgi?chfieldto=$2&query_format=advanced&chfield=resolution&chfieldfrom=$1&chfieldvalue=FIXED&bug_severity=regression&bug_severity=blocker&bug_severity=critical&bug_severity=major&bug_severity=normal&bug_severity=minor&bug_severity=trivial&bug_status=RESOLVED&version=D2&version=D1%20%26%20D2&component=DMD&resolution=FIXED&product=D, DMD Bugs Fixed)
	DRUNTIMEBUGSFIXED2=$(LINK2 https://issues.dlang.org/buglist.cgi?chfieldto=$2&query_format=advanced&chfield=resolution&chfieldfrom=$1&chfieldvalue=FIXED&bug_severity=regression&bug_severity=blocker&bug_severity=critical&bug_severity=major&bug_severity=normal&bug_severity=minor&bug_severity=trivial&bug_status=RESOLVED&version=D2&version=D1%20%26%20D2&component=druntime&resolution=FIXED&product=D, Druntime Bugs Fixed)
	PHOBOSBUGSFIXED2=$(LINK2 https://issues.dlang.org/buglist.cgi?chfieldto=$2&query_format=advanced&chfield=resolution&chfieldfrom=$1&chfieldvalue=FIXED&bug_severity=regression&bug_severity=blocker&bug_severity=critical&bug_severity=major&bug_severity=normal&bug_severity=minor&bug_severity=trivial&bug_status=RESOLVED&version=D2&version=D1%20%26%20D2&component=Phobos&resolution=FIXED&product=D, Phobos Bugs Fixed)

    STDMODREF = <a href="phobos/std_$1.html">$(D $2)</a>
    XREF = <a href="phobos/std_$1.html#$2">$(D $2)</a>
    CXREF = <a href="phobos/core_$1.html#$2">$(D $2)</a>