Improve this page Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone. Page wiki View or edit the community-maintained wiki page associated with this page.

Change Log

Version D 2.063 May 28, 2013

Language Changes

Const and immutable fields with initializers are now warned about:

Eventually, they will be deprecated, and then will be an error. Such fields should now be changed to enum, static or immutable.

Eventually, new behavior for them will be enabled, as follows:

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

struct S
{
    // used to be implicitly static in 2.062, now non-static in 2.063
    immutable int[] arr = [1, 2];

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

This means that code which accessed such declarations without the 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;  // error in 2.063, needs 'this'

    // used to be size 1 in 2.062 and earlier
    static assert(S.sizeof == size_t.sizeof + size_t.sizeof);  // ptr + length for the array
}

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

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

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

Rationale:

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

Constructor qualifiers are taken into account when constructing objects:

A qualified constructor is now invoked when a const/immutable/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"
}

This has the consequence that aggregates which have only immutable or 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
}

On the other hand, aggregates which do not have shared or immutable constructors can no longer be used to construct shared or 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
}

However, if an aggregate has a 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
}

Struct members which require non-bitwise comparison are now properly compared.

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
}

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

Array copy operations now always require using the slice syntax:

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)
}

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)
}

Rationale:

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

Types no longer act as arguments in typeof expressions:

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;
}

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

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

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

Rationale:

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

The index variable in a foreach range is no longer implicitly a reference:

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
}

If the user wants to modify the index variable he must use the ref keyword:

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

Rationale:

Making the index variable implicitly ref can introduce bugs that are hard to track down.

Associative array entries are no longer default-initialized before assignment:

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
}

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
}

Rationale:

Default-initialization during assignment can be a source of bugs.

The const attribute is no longer inherited in overriden methods.

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'
}

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
}

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 { }
}

typeof(null) no longer implicitly converts to T[]:

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);
}

However the implicit conversion would end up generating wrong code. To work around this, make sure the return type is typed properly, or use (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
}

The Template This Parameter now changes the member function qualifier:

The Template This Parameter can now be used to infer the qualifier of this to member functions:

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

void main()
{
     immutable S s;
     s.foo();  // makes S.foo immutable
}

Array slices are now r-values:

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
}

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 `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
}

Rationale:

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);
}

Accessing a non-static field without a this reference is only allowed in certain contexts:

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

- offsetof, 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
}

- 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()'
}

- When accessing static fields implicitly using an 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()'
}

Arrays no longer implicitly convert to a pointer:

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
}

This feature has now been completely removed. The workaround is to either use the .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
}

Language Enhancements

Expressions which return unique objects can be implicitly castable to immutable:

Expressions such as new for objects and arrays, and 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
}

Static array of void can now be user-initialized.

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
}

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
}

The .init property effectively zero-initializes the array.

Rationale:

The restriction has been lifted to allow generic code to use .init without having to specialize for static void arrays.

Aggregates can now contain multiple invariants:

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
}

Methods of templated aggregates can now infer attributes:

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.foo becomes pure and callable from main()
    assert(s.square(2) == 4);  // ok
}

is expression no longer requires an identifier:

In some cases the 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
    }
}

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
    }
}

Dynamic arrays of known size can be implicitly cast to static arrays in some contexts:

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
}

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
}

Limitations:

- 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
    }
}

Tuples can now be void-initialized:

You can now void-initialize a tuple variable:

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

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

Template constraints can now be put after the inheritance list:

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
{
}

This restriction has been lifted, so you can now write:

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

Tuples can now be compared for equality:

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
}

This also means you can now compare 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);
}

In addition to that, builtin .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.
    // This can also be used as a workaround for Issue 3789.
    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);
}

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);
}

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);
}

Fields with initializers can now be re-initialized in a const constructor:

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
    }
}

Added the isNested trait for discovery of aggregates and functions with context pointers:

The new 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));
}

Templates can now be nested inside of functions:

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

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

UFCS now works with scoped local imports:

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
}

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

Added __FUNCTION__, __PRETTY_FUNCTION__ and __MODULE__:

A new set of special keywords were added. Together with __FILE__ and __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;
}

The above will output:

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

DDoc: Deprecated declarations are now wrapped in a DEPRECATED macro:

module test;

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

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

macros.ddoc:

DEPRECATED=<del>$0</del>

The above ddoc file can then be used when the documentation is being generated:

$ dmd -D -o- test.d macros.ddoc

Added documented unittest feature for verifiable code example generation:

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);
}

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.

Compiler Enhancements

Added -main switch which adds an empty main function:

The -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);
}

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

$ dmd -unittest -main -run test.d

Added -cov=percentage switch for minimal coverage tests.

The -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();
}

Example of coverage testing:

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

Added ability to override the mangling of a symbol with a compiler pragma:

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

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

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.

Phobos Changes

std.typecons.scoped implementation changed, potentially breaking some user-code:

User-code which used the std.traits.ReturnType trait to retrieve the type of a scoped call will have to be changed to use the 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
    }
}

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

Another benefit of the new implementation is that scoped can now be aliased for usability purposes:

class A
{
    this(int) { }
}

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

Phobos Enhancements

std.process has been redesigned from the ground up and introduces a new API and functionality:

The new 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 std.process documentation.

std.getopt can now set booleans to false:

Example code:

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

When invoked via --flag=false, it will set flag to false.

Added ownerTid property in std.concurrency:

It is now easier to send a message from a child thread to its owner thread. Simply use the 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");
}

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

Version D 2.062 Feb 18, 2013

Language Changes

typeof() change:

As a result of fixing Bugzilla 6408, the usage of 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));
}

The expression in typeof(T[0]) used to be wrongly interpreted as the element type of T, however in v2.062 it is interpreted as a static array of element T with length 0. To work around this the user can either use a trait from the standard library, or use the .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));
}

alias syntax change:

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

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

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
}

List of all bug fixes and enhancements:

DMD Compiler regressions

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

DMD Compiler bugs

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

DMD Compiler enhancements

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

Phobos regressions

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

Phobos bugs

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

Phobos enhancements

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

Druntime bugs

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

Website regressions

Bugzilla 9467: Operator Overloading anchors are broken
Bugzilla 9492: [2.052 beta] Stylesheet not found for off-line HTML docs

Website bugs

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

Website enhancements

Bugzilla 9302: Document extern properly

Version D 2.062
Version D 2.061
Version D 2.060
Version D 2.059
Version D 2.058
Version D 2.057
Version D 2.056
Version D 2.055
Version D 2.054
Version D 2.053
Version D 2.052
Version D 2.051
Version D 2.050
Version D 2.049
Version D 2.048
Version D 2.047
Version D 2.046
Version D 2.045
Version D 2.044
Version D 2.043
Version D 2.042
Version D 2.041
Version D 2.040
Version D 2.039
Version D 2.038
Version D 2.037
Version D 2.036
Version D 2.035
Version D 2.034
Version D 2.033
Version D 2.032
Version D 2.031
Version D 2.030
Version D 2.029
Version D 2.028
Version D 2.027
Version D 2.026
Version D 2.025
Version D 2.023
Version D 2.022
Version D 2.021
Version D 2.020
Version D 2.019
Version D 2.018
Version D 2.017
Version D 2.016
Version D 2.015
Version D 2.014
Version D 2.013
Version D 2.012
Version D 2.011
Version D 2.010
Version D 2.009
Version D 2.008
Version D 2.007
Version D 2.006
Version D 2.005
Version D 2.004
Version D 2.003
Version D 2.002
Version D 2.001
Version D 2.000
changelog for 1.0
tech support

Version D 2.061 Jan 1, 2013

New/Changed Features

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).
Complete list of New/Changed Features

Bugs Fixed

Version D 2.060 Aug 2, 2012

New/Changed Features

std.string: 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.
std.bitmanip: Added peek, read, write, and append for converting ranges of bytes to and from integral types.
std.container: Added DList, which is an implementation of a doubly-linked list.
Added std.file.tempDir which returns the path to a directory where a program can put temporary files.
std.process: Added escapeShellCommand, escapeShellFileName, and escapeWindowsArgument. Documented browse function.
std.range: Added RefRange, which effectively makes it possible to pass a range by reference.
std.traits: Added KeyType, ValueType, isScalarType, isBasicType, and SetFunctionAttributes templates.
std.utf: Added overload of codeLength which operates on a string.
std.traits: areAllSafe has been scheduled for deprecation. Please use allSatisfy(isSafe, ...) instead.
clear has been renamed to destroy, and clear (as an alias to destroy) has been scheduled for deprpecation.
Capitalized std.traits.pointerTarget to PointerTarget. Old one is scheduled for deprecation.
std.algorithm.indexOf - which was scheduled for deprecation - has been deprecated (it was easily confused with std.string.indexOf). Please use countUntil instead.
std.cpuid - which was scheduled for deprecation - has been deprecated. Please use core.cpuid instead.
std.conv.ConvError and ConvOverflowException - which were scheduled for deprecation - have been deprecated. Please catch ConvException and ConvOverflowException instead.
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.
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.
std.format.FormatError - which was scheduled for deprecation - has been deprecated. Please catch FormatException instead.
std.file.listDir has been deprecated. Please use std.file.dirEntries instead.
std.range.replicate - which was scheduled for deprecation - has been deprecated. Please use repeat instead.
std.range.SortedRange.canFind - which was scheduled for deprecation - has been deprecated. Please use SortedRange.contains instead.
std.socket: timeval and linger - which were scheduled for deprecation - have been deprecated. Please use TimeVal and Linger.
std.stdio.isStreamingDevice has been scheduled for deprecation. Please use isFileHandle instead.
The deprecated std.typecons.defineEnum has been removed.
UtfException - which was scheduled for deprecation - has been deprecated. Please use UTFException instead.
The deprecated overloads of std.array.insert and std.array.replace have been removed. Please use insertInPlace and replaceInPlace instead.
The deprecated toISOExtendedString and fromISOExtendedString functions in std.datetime have been removed. Please use toISOExtString and fromISOExtString instead.
The deprecated std.file.getTimesPosix has been removed. Please use std.file.getTimes instead.
The deprecated overloads of isFile, isDir, and isSymLink in std.file which took uint have been removed. Please use attrIsFile, attrIsDir, and attrIsSymlink instead.
The deprecated std.file.DirEntry.timeStatusChanged has been removed. Please use std.file.DirEntry.attributes to get at that information if you need it.
The deprecated std.contracts module has been removed. Please use std.exception instead.
The deprecated std.arg, std.bind, and std.loader modules have been removed.
Added TypeInfo.rtInfo property to get library defined runtime info.
Added front end support for AVX 256 bit SIMD instructions.
Default arguments and parameter identifiers (if any) are added to the tuple generated from IsExpression's __parameters case.
Changed the way the align attribute works, to make it more usable and comprehensible. Default alignment has not changed.
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.
HTML input file support completely removed.
Bugzilla 3150: cast from dynamic array to ulong is allowed
Bugzilla 3866: anonymous delegate with default parameters cross-talks to another anonymous delegate
Bugzilla 4174: Template interface functions not allowed, making operator overloads difficult
Bugzilla 6652: 1. Warn modifying non ref variable if -w is specified.
Bugzilla 7243: Compiler should call separate function when allocating a struct on the heap
Bugzilla 7923: Please remove 'deprecated' from setAssertHandler()
Bugzilla 8105: in ref
Bugzilla 8127: dmd link library paths not given precedence over gcc defaults
Bugzilla 8221: typeof(null) rejected as return type for covariant overrides

Druntime Bugs Fixed

Bugzilla 6909: incorrect definition of the OVERLAPPED struct in core.sys.windows.windows ?

Library Bugs Fixed

Bugzilla 2328: setTypeInfo in gc.d backwards.
Bugzilla 2588: std.signals should not use 'length' stealth keyword in indexing
Bugzilla 4405: all function - returns whether predicate is true for all elements in a range
Bugzilla 4603: array(iota(1, 0)) error
Bugzilla 4605: Wrong print of an int[string] aa
Bugzilla 4629: BufferedFile.printf() wants char[] as first argument
Bugzilla 4695: std.range.zip is broken
Bugzilla 4744: std.conv: string->enum doesn't look for longer match
Bugzilla 4822: Problem with std.stdio.File.writef("%c")
Bugzilla 5011: std.container: SList linearRemove produces wrong results
Bugzilla 5089: feqrel does not compile for floats
Bugzilla 5260: std.math.feqrel() returns negative number
Bugzilla 5346: instantiation of std.conv.toImpl and std.format.formatValue fails for unions
Bugzilla 5354: formatValue: range templates introduce 3 bugs related to class & struct cases
Bugzilla 5786: std.algorithm.sort does not work with std.container.Array: Range violation
Bugzilla 5843: Unable to convert a struct with an alias-this to long/ulong to int, using std.conv.to!int.
Bugzilla 5970: fix BigInt.toString
Bugzilla 6027: bigint to!string conversion and its implications
Bugzilla 6175: String corruption when passing static char arrays to std.conv
Bugzilla 6191: removechars doesn't accept a const string
Bugzilla 6197: std.traits.isImplicitlyConvertible returns some wrong results.
Bugzilla 6222: A problem with iota() using size_t
Bugzilla 6231: [patch] std.conv.to/std.format.: Structs with toString and isInputRange match multiple templates.
Bugzilla 6273: Tuple [] operator in pure function
Bugzilla 6379: std.container.SList fails to compile
Bugzilla 6437: Refcounted calls dtor before ctor, never calls dtor for globals
Bugzilla 6547: Call to std.algorithm.remove causes compile error
Bugzilla 6580: scoped classes are aligned incorrectly
Bugzilla 6597: to!SomeString should use std.format.formatValue
Bugzilla 6642: SysTime should not be hasUnsharedAliasing
Bugzilla 6892: Formatted write with specified length of enum member
Bugzilla 6926: std.process.system return wrong exit code
Bugzilla 7022: File.byLine doesn't release file handle
Bugzilla 7138: Can't call array() on dirEntries
Bugzilla 7317: writeln cannot handle alias this of array type
Bugzilla 7326: write interprets enum with byte backing type as a character
Bugzilla 7348: to!string(null) matches more than one template declaration
Bugzilla 7356: Implement KeyType, ValueType for hashes in std.traits
Bugzilla 7360: Predicate templates in std.traits should consider alias this
Bugzilla 7515: The new std.string.translate is slow for ASCII text
Bugzilla 7537: `File.tmpfile` requires administrator rights on Windows
Bugzilla 7561: std.net.curl broken
Bugzilla 7660: toImpl conflict in std.conv
Bugzilla 7796: std.typecons.Unique is using writeln without importing std.stdio
Bugzilla 7824: isInputRange fails to recognize inout(T)[]
Bugzilla 7831: Unlisted @@@BUG in File.detach causes FILE* leaks when reopening
Bugzilla 7878: A problem with purity and general templated algorithms
Bugzilla 7898: [CTFE] std.algorithm:copy fails when used with two arrays
Bugzilla 7909: to!(enum)(string) and to!(string)(enum) break when enum is integral
Bugzilla 7919: Sample code works on GDC but fails with DMD
Bugzilla 7936: std.random.randomSample always returns the same first value when passed a random number generator
Bugzilla 7937: Range iota.Result should be const where possible
Bugzilla 7944: std.range.iota.popFront() cycles when the range is empty
Bugzilla 7948: std.range.zip broken with requireSameLength
Bugzilla 7962: std.regex: Captures.length() returns incorrect value
Bugzilla 7973: BigInt %= long/ulong gives wrong value
Bugzilla 7975: Incorrect quotes escaping in std.format
Bugzilla 7982: iota broken when start and end are unsigned and step is negative.
Bugzilla 7993: BigInt divide-by-1 error
Bugzilla 8003: Phobos uses deprecated std.path sep symbol
Bugzilla 8011: BigInt ++ and -- do wrong thing on negative numbers
Bugzilla 8015: std.typecons.Tuple does not support struct with alias method this
Bugzilla 8022: BigInt division bug (2)
Bugzilla 8026: Fix or disallow randomShuffle() on fixed-sized arrays
Bugzilla 8031: If a class have some signals it's impossible for a derived class to have any signals
Bugzilla 8037: hasElaborateDestructor is false for non-zero-length static array of structs with elaborate destructor
Bugzilla 8039: `scoped` doesn't call any elaborate destructors for struct fields
Bugzilla 8040: writeln(null) too
Bugzilla 8055: [Regression 2.059] std.algorithm.move corrupts moved object field
Bugzilla 8057: std.algorithm.move cannot use for nested struct
Bugzilla 8080: 'alias this' causes toString to be shadowed by aliased object
Bugzilla 8112: std.algorithm.fill must accept InputRange
Bugzilla 8158: std.algorithm.min fails to compile with user-defined types
Bugzilla 8164: BigInt from char[] too
Bugzilla 8165: BigInt opAssign return value
Bugzilla 8171: [Regression 2.060head] Broken std.algorithm.move for nested struct has no member
Bugzilla 8186: Formatting class object has an alias this to int* field is broken.
Bugzilla 8187: replaceFirst doesn't work for string[] haystack
Bugzilla 8191: cstream.printf is completely unusable on x86_64
Bugzilla 8195: Segfault when comparing a VariantN to a non-variant type which it holds
Bugzilla 8203: Use of std.regex.match() generates "not enough preallocated memory" error
Bugzilla 8214: blocking option for TaskPool.finish()
Bugzilla 8233: std.array.array fails to compile with ranges of immutable elements which have a length property
Bugzilla 8240: std.algorithm.joiner and empty inputRangeObject
Bugzilla 8264: [std.conv.to] constructing conversion doesn't work with alias this
Bugzilla 8310: writeln of Range of fixed size array
Bugzilla 8323: std.string.chompPrefix does not handle differing string types properly
Bugzilla 8362: std.traits.isSafe doesn't work with unsafe lamdba functions
Bugzilla 8386: writeln stopped working with wstring
Bugzilla 8398: enforceEx cannot be used with OutOfMemoryError
Bugzilla 8450: std.traits.isSafe doesn't work with unsafe lamdba functions

DMD Bugs Fixed

Bugzilla 1175: nested class inheritance
Bugzilla 1780: Type tuple deduction failure for class templates
Bugzilla 2472: Delegates are not lvalue.
Bugzilla 2962: ICE(glue.c) or bad codegen passing variable as template value parameter
Bugzilla 3290: accepts-invalid: non-const by-ref foreach over a const array is accepted
Bugzilla 3574: post-condition in void main() is not evaluated if there is no return statement
Bugzilla 3608: Allow isExpression and templates to capture template parameters and FQN of template
Bugzilla 3703: static array assignment
Bugzilla 3895: Appending a double[] to a float[] generates wrong code
Bugzilla 4024: Last catch only accepts block statement
Bugzilla 4155: return of NaN to temporary fails equality test
Bugzilla 4288: Error on passing delegate to C linkage function
Bugzilla 4364: ICE(class.c) compiling a struct def named 'Object' followed by a class definition
Bugzilla 4510: [tdpl] ref with a wrong type specifier is accepted
Bugzilla 4583: PIC code not working: EBX register set incorrectly
Bugzilla 4785: auto return of a function with in contract
Bugzilla 4884: Using template struct parameters in method definition fails with "parameter _param_0 is already defined"
Bugzilla 4953: Regression(2.031): templates don't do implicit conversion properly
Bugzilla 4967: member default initializers not working in static struct initializers
Bugzilla 5039: Cannot use invariant() with auto methods
Bugzilla 5082: delegate alias parameters are silently accepted inside structs. limits most of std.algorithm, etc.
Bugzilla 5435: Static foreach over tuple ignores type annotation
Bugzilla 5437: Problems with length of std.traits.EnumMembers
Bugzilla 5473: Members of const-qualified classes are not const themselves.
Bugzilla 5737: postblit not called for locals initialized from ref functions
Bugzilla 5809: [64 bit] wrong code for *p==0, when widening conversion occurs
Bugzilla 5896: const overload matching is succumb to template parameter one
Bugzilla 6189: [64bit] optimizer: register content destroyed in function prolog
Bugzilla 6199: [GSoC] Postblit not called when returning a reference to a by-value function
Bugzilla 6470: postblits not called on arrays of structs
Bugzilla 6475: template identifier is not a member of alias
Bugzilla 6591: di header generation loses selective import symbols
Bugzilla 6612: Associative arrays with associative array keys literals
Bugzilla 6636: Destructors of static array elements are not called on function parameter
Bugzilla 6637: Postblits of static array elements are not called on function argument
Bugzilla 6758: std.c.stdarg problems with 8 or more integer arguments on x86_64
Bugzilla 6891: template with uint value parameter causes several issues
Bugzilla 7396: Indicate default alignment with 0.
Bugzilla 7385: Bad error message missing line number on invalid array op that isn't special cased
Bugzilla 7413: Vector literals don't work
Bugzilla 7414: Vector literal assignment doesn't work in global scope
Bugzilla 7418: Overloading doesn't work with aliases declared inside templates
Bugzilla 7453: Can't return value from within opApply
Bugzilla 7478: stack overflow compiling with -deps -release -inline -noboundscheck
Bugzilla 7494: Selective import does not work inside a function
Bugzilla 7506: Postblit does not called properly with inlining
Bugzilla 7530: Postblit not called structs returned from an array index expr.
Bugzilla 7560: Base class overloaded methods created by mixins can't be overriden
Bugzilla 7581: Compiler uses wrong instructions to move complex value from ST to xmm registers
Bugzilla 7585: functions in templates inferred as delegate
Bugzilla 7750: while(true) loop with try/catch block causes segfault
Bugzilla 7770: __dollar cannot be read at compile time
Bugzilla 7784: ICE with self-referencing literals
Bugzilla 7793: static assert( void_function() ) gives misleading error message
Bugzilla 7807: Ambiguous virtual function error on const overloading with covariant return types
Bugzilla 7851: Internal error: e2ir.c 688
Bugzilla 7880: [CTFE] cast from void array allowed with different results than at runtime
Bugzilla 7893: Spec completely wrong for D variadic arguments on 64 bits
Bugzilla 7894: [CTFE] - goto within ForStatement restarts loop
Bugzilla 7906: [ICE] enum declaration with invalid array literal crashes dmd
Bugzilla 7907: [ICE] invalid expression on template argument crashes dmd
Bugzilla 7911: Nested static if failing to execute
Bugzilla 7922: alias this causes weird formatting issues for strings
Bugzilla 7929: Broken semantic of StructInitializer with const
Bugzilla 7931: Error message with _error_ with var[1,2]
Bugzilla 7932: Corrupted argument inside out contract in x86_64
Bugzilla 7933: Illegal interaction of templates
Bugzilla 7941: Regression(2.059): Type check is ignored when manifest constant initializer is function literal
Bugzilla 7943: UFCS does not work with alias this
Bugzilla 7945: alias this doesn't work on function ref parameter
Bugzilla 7949: [ICE] (cgcod.c) with SIMD array
Bugzilla 7950: Type tuples are incorrectly flattened in base type list of interface
Bugzilla 7951: DMD: Internal error: backend/cgxmm.c 567
Bugzilla 7965: Invalid outer function scope pointer in some cases
Bugzilla 7974: forward reference of mixin declaration
Bugzilla 7983: ICE with getMember on a unittest member
Bugzilla 7987: [CTFE] cannot compare arrays of slices
Bugzilla 8002: Excess initial errors when passing template args to non-templated struct
Bugzilla 8004: Direct call of function literal should consider default arguments
Bugzilla 8005: Lambda with parameter type inference should consider default args
Bugzilla 8016: Methods defined in external object files when template alias parameter is involved
Bugzilla 8032: `mixin template` before virtual method with same method causes an error
Bugzilla 8036: Zero-length static array of structs with elaborate destructor as struct or class field is rejected
Bugzilla 8038: #line which is in a double template instantiation doesn't work
Bugzilla 8060: xmmstore cannot allocate store for optimized operation that uses int and floats
Bugzilla 8064: return reference semantics not obeyed on delegates?
Bugzilla 8066: ICE on missing return statement if invariant is present
Bugzilla 8069: incorrect ambiguous virtual function error
Bugzilla 8073: Regression (git) Error: undefined identifier __result
Bugzilla 8089: Importing package as module causes segfault
Bugzilla 8091: Optimizer generates wrong code when reducing comparisons
Bugzilla 8094: Static if matching using alias parameter in template fails
Bugzilla 8095: [64 bit] Wrong code generation with spilled register, -m64 -O
Bugzilla 8098: Inner class method can modify outer's members regardless of constancy
Bugzilla 8099: Inner class's outer pointer matches constancy of inner, but can be set to object of arbitrary constancy
Bugzilla 8182: with a lazy struct parameter, the struct's destructor is called on the generated delegate
Bugzilla 8180: UFCS writeln doesn't work with Tuples
Bugzilla 8113: alias this doesn't forward opCall
Bugzilla 8123: alias declaration lookup is broken
Bugzilla 8125: TypeInstance dedunction problem
Bugzilla 8129: Cannot deduce template function when using partially specified type in function parameter
Bugzilla 8147: Blah!R.init now requires parens - (Blah!R).init
Bugzilla 8168: dmd crashes when asm statement with wrong opcode
Bugzilla 8169: Method loses its compile-time evaluability when used through alias this
Bugzilla 8185: Pure functions and pointers
Bugzilla 8188: need this to access member when mixining in a function
Bugzilla 8190: Externally defined struct error message
Bugzilla 8194: "Function cannot access frame" even though all I requested was the type
Bugzilla 8198: Nested lambda inference doesn't work
Bugzilla 8199: stack is not aligned in finally block
Bugzilla 8212: shared value data structures should implicitly cast to mutable
Bugzilla 8216: CTFE should allow 'pointer is inside range' comparisons
Bugzilla 8226: Global lambda assign to const/immutable
Bugzilla 8237: Error message with _error_ when using failed type inference in template parameter
Bugzilla 8241: cannot use template function literal as default alias argument
Bugzilla 8242: cannot use template function literals at module scope
Bugzilla 8249: Spurious error message with templates and alias this
Bugzilla 8252: no UFCS for 0 literal
Bugzilla 8276: [CTFE] ICE when reading variable from nested function
Bugzilla 8283: ICE(cod1.c): returning struct with constructor as member of another struct
Bugzilla 8315: Invalid nested-ref check in template constraint
Bugzilla 8335: `ref` is ignored for static array of stucts with postblit argument
Bugzilla 8390: Refused array operation mutable[] += const[]
Bugzilla 8397: parameter types are not checked when assigning a function literal
Bugzilla 8423: Wrong code for bool parameter in 5th integer register.
Bugzilla 8429: [2.060 beta] 'version' rejected inside 'static if's
Bugzilla 8434: [Regression 2.058] cannot implicitly convert expression (vs1.opCast()) of type const(Vector2D) to object.Object
Bugzilla 8437: [2.060 beta] static struct no size yet for forward reference
Bugzilla 8442: [2.060 beta] Empty array enum not treated as immutable
Bugzilla 8453: Associative array keys refused as property by sort
Bugzilla 8454: [ICE] (backend\cg87.c 3497) with cdouble and sqrt

Version D 2.059 Apr 12, 2012

New/Changed Features

Add predefined Ddoc macro SRCFILENAME
Changed lexer to support # as a token, preserving #line's original behavior
added AES, PCLMULQDQ, RDRAND, AVX, VAES, VPCLMULQDQ, FMA, FP16C to core.cpuid
Bugzilla 435: Constructors should be templatized
Bugzilla 2367: Overloading error with string literals
Bugzilla 3382: [tdpl] Implement uniform function call syntax
Bugzilla 4536: Typetuples (T...) should have an .init member
Bugzilla 5525: Eponymous templates should allow for overloaded eponymous members
Bugzilla 7105: relax inout rules
Bugzilla 7833: Changelog should clearly mention struct literal/opCmp/opEquals/toHash changes
Strive to make toHash, toString, opEquals and opCmp functions pure, nothrow, const and @safe. Soon, this will become a requirement.
The deprecated std.date, std.dateparse, and std.gregorian modules have been removed. Please use std.datetime instead.
Several deprecated functions in std.file have been removed.
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").
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.
Get rid of Win9x support.
std.typecons: Added Proxy mixin template.
std.format: Added documentation about compound format specifier.

Druntime Bugs Fixed

Library Bugs Fixed

Bugzilla 4604: A stack overflow with writeln
Bugzilla 5523: std.regex handles "\s" and "\W" (etc.) inside square brackets improperly
Bugzilla 5652: Add \p and \P unicode properties to std.regex
Bugzilla 5674: AssertError in std.regex
Bugzilla 5964: std.stdio.readln can throw a UnicodeException
Bugzilla 6217: [GSOC] result of std.algorithm.map is not movable
Bugzilla 6403: Upgrade std.regex to Unicode UTS #18 Level 1 support
Bugzilla 6892: Formatted write with specified length of enum member
Bugzilla 7111: New regex engine cannot match beginning of empty string
Bugzilla 7138: Can't call array() on dirEntries
Bugzilla 7264: Can't iterate result from 4-arg dirEntries as string
Bugzilla 7299: std.uni missing doc comments
Bugzilla 7300: std.regex.ShiftOr!dchar.search is broken
Bugzilla 7374: stdin.byLine() throws AssertError on empty input
Bugzilla 7460: std.windows.registry reports a false exception message
Bugzilla 7476: Write(ln) functions no longer accept retro range
Bugzilla 7628: std.format formatValue incorrect overload
Bugzilla 7674: regex replace requires escaped format
Bugzilla 7679: std.regex.split and splitter don't work w/ ctRegex
Bugzilla 7718: regex and ctRegex produce different results

DMD Bugs Fixed

rdmd: --force now works with --eval
rdmd: update --eval's import list
Bugzilla 176: [module] message "module and package have the same name"
Bugzilla 783: Cannot use an array w/ const or variable index as new[] size argument.
Bugzilla 977: Expressions inside a struct or array initializer get wrong line number
Bugzilla 3279: Confusing error message when comparing types
Bugzilla 3354: invalid number of args accepted for 1/2 arg floating point instructions
Bugzilla 3509: Cannot forward reference a template mixin's members in a compile-time context
Bugzilla 3510: Cannot forward reference a templated type from within a template mixin
Bugzilla 3559: DMD 1.048+ fails to take function pointer from overloaded member functions
Bugzilla 3630: bad error location in "has no effect in expression" error
Bugzilla 3682: Regression(2.038) is expression fails to match types
Bugzilla 3812: Missing line number for implicit cast of variadic function to array
Bugzilla 3822: Invalid optimization of alloca called with constant size
Bugzilla 3927: array.length++; is an error, but ++array.length compiles
Bugzilla 4241: duplicate union initialization error doesn't give a file location
Bugzilla 4269: Regression(2.031): invalid type accepted if evaluated while errors are gagged
Bugzilla 4507: use spellchecker when override function doesn't override anything
Bugzilla 4820: Regression(1.058, 2.044) in DStress caused by changeset 452
Bugzilla 4854: Regression(2.047, Mac 10.5 only) writefln Segmentation fault if no globals
Bugzilla 4993: Temporary values and opIndexAssign
Bugzilla 5181: Excess cast on in-place operation op= involving conversion
Bugzilla 5412: import wtf2
Bugzilla 5554: [qtd] Covariance detection failure
Bugzilla 5590: Regression(2.036) ICE(e2ir.c): when using .values on enum which is associative array
Bugzilla 5733: Calling opDispatch As Template Results in Compiler Infinite Loop
Bugzilla 5879: Not all frontend errors use stderr
Bugzilla 5889: Struct literal/construction should be rvalue (it binds to ref parameters)
Bugzilla 6391: Line-less error when passing the '.im' of floating pointer value by reference
Bugzilla 6438: [CTFE] wrong error "value used before set" when slicing =void array
Bugzilla 6611: better error message for array post increment/decrement
Bugzilla 6681: struct constructor call is converted to struct literal that breaks union initialization
Bugzilla 6685: Allow using "with" with rvalues
Bugzilla 6699: More cases of __error in error messages
Bugzilla 6738: Can't call templatized property function from within a struct/class method
Bugzilla 6785: Wrong error message from pragma(msg) of failed instantiation
Bugzilla 6982: immutability isn't respected on associative array assignment
Bugzilla 7038: Type mismatch with const struct
Bugzilla 7110: opSlice() & opIndex functions works unstable as template arguments
Bugzilla 7288: ICE(toir.c): with lambda return + auto
Bugzilla 7353: NRVO not properly working with inferred return type
Bugzilla 7380: Crash trying to use address of variable in struct constructor at module level
Bugzilla 7399: Broken import statement in trySemantic() causes silent compiler error
Bugzilla 7406: tuple foreach doesn't work with mixed tuples
Bugzilla 7411: Deduce base type from vector types in templates
Bugzilla 7439: Compound assignment causes segmentation fault
Bugzilla 7452: Function using enforce() cannot be inferred as @safe because of anonymous function due to lazy argument
Bugzilla 7462: Error message with _error_ in overridden function
Bugzilla 7463: Duplicated error message with bad template value parameter
Bugzilla 7473: [CTFE] Non-ref argument behaves as if it's a ref argument
Bugzilla 7481: Compiler should 'soldier on' after template errors
Bugzilla 7493: Initialization of void[][N]
Bugzilla 7499: ICE(cast.c line 1495) with lambda array
Bugzilla 7500: [ICE] (template.c line 5287) with immutable lambda function
Bugzilla 7502: 2.056 regression: Assigning .init takes forever to compile for large structs
Bugzilla 7504: Cannot assign an object of type 'typeof(null)' to an array
Bugzilla 7518: std.array.empty doesn't work for shared arrays
Bugzilla 7525: [2.058 regression] Broken return type inference for delegate returns
Bugzilla 7527: [CTFE] Segfault when slicing a pointer at compile time
Bugzilla 7536: ctfeAdrOnStack triggered
Bugzilla 7544: ICE(interpret.c) Catching an exception with a null catch block
Bugzilla 7545: ICE(cast.c) Merge integral types through alias this
Bugzilla 7547: -deps output lists object as a top level module
Bugzilla 7550: Missing AVX instruction VPMULDQ
Bugzilla 7552: Cannot get and combine a part of overloaded functions
Bugzilla 7554: Immutable function pointer arguments too
Bugzilla 7557: Sea of errors after template failure
Bugzilla 7562: DMD crashes by using TemplateThisParameter
Bugzilla 7563: Class members with default template arguments have no type
Bugzilla 7568: pragma(msg) segfaults with an aggregate including a class.
Bugzilla 7578: ICE on indexing result of vararg opDispatch
Bugzilla 7580: Identity assignment of Nullable crashes dmd
Bugzilla 7582: Untyped nested delegate literals don't compile
Bugzilla 7583: [CTFE] ICE with tuple and alias this
Bugzilla 7589: __traits(compiles) does not work with a template that fails to compile
Bugzilla 7592: Conversion from ireal to ifloat broken when using xmm
Bugzilla 7595: Data being overwritten.
Bugzilla 7608: __traits(allMembers) is broken
Bugzilla 7618: delegate/function pointer call bypass parameter storage class
Bugzilla 7621: Immutable type equivalence problem
Bugzilla 7633: Missing CTFE error message
Bugzilla 7639: Undefined enum AA key crashes compiler
Bugzilla 7641: std.typecons.Proxy incorrectly allows implicit conversion to class
Bugzilla 7643: Whole tuple slice isn't resolved as expected
Bugzilla 7649: Bad lambda inference in default function argument
Bugzilla 7650: Bad lambda inference in associative array literal
Bugzilla 7667: ICE(interpret.c): 'ctfeStack.stackPointer() == 0'
Bugzilla 7669: Broken inout deduction with static array type
Bugzilla 7670: UFCS problem with @property and structs
Bugzilla 7671: Broken inout deduction of shared(inout(T[n])) from immutable(int[3])
Bugzilla 7672: Remove top const doesn't work for inout array type.
Bugzilla 7681: Regression(2.059head):ICE:opCatAssign(delegate) to undefined identifier
Bugzilla 7682: shared array type and "cast() is not an lvalue" error
Bugzilla 7684: IFTI and shared overload doesn't work
Bugzilla 7694: Internal error: e2ir.c 1251 when calling member function inside struct via alias param
Bugzilla 7695: Regression(2.058): ICE(mtype.c) on associative array with keys of struct type with const members
Bugzilla 7698: can't specialize parameterized template value
Bugzilla 7699: Cannot get frame pointer to in contract when compiling with -inline
Bugzilla 7702: opDispatch goes into infinite loop
Bugzilla 7703: [UFCS] explicit template function instantiation as property
Bugzilla 7705: lambda syntax doesn't allow some valid signatures
Bugzilla 7713: lambda inference doesn't work on template function argument
Bugzilla 7722: Refuse normal functions to be used as properties
Bugzilla 7731: Assertion failure: 't' on line 7911 in file 'mtype.c'
Bugzilla 7732: [CTFE] wrong code for a struct called AssociativeArray
Bugzilla 7735: Functions with variadic void[][]... arguments corrupt passed data
Bugzilla 7742: 'More initializers than fields' error with correct number of fields
Bugzilla 7743: Parsing problem with nothrow delegate
Bugzilla 7745: Regression (1.x git-415e48a) Methods defined in external object files when a pointer to it is taken
Bugzilla 7751: [ICE] (Regression 2.059head) From auto and forward reference
Bugzilla 7754: static this() in template is stripped during header gen
Bugzilla 7755: regression(2.059head): ICE in glue.c
Bugzilla 7757: Inout function with lazy inout parameter doesn't compile
Bugzilla 7761: lambda expression doesn't parse attributes
Bugzilla 7768: More readable template error messages
Bugzilla 7769: relax inout rule doesn't work for template function
Bugzilla 7722: Refuse normal functions to be used as properties
Bugzilla 7773: UCFS syntax on built-in attributes too?
Bugzilla 7781: [CTFE] Segmentation fault on 'mixin({return;}());
Bugzilla 7782: [ICE] With wrong import syntax
Bugzilla 7785: [CTFE] ICE when slicing pointer to variable
Bugzilla 7786: dmd crashes with invalid module name
Bugzilla 7789: [CTFE] null pointer exception on setting array length
Bugzilla 7794: Sea of errors when calling regex() after compile error
Bugzilla 7808: Nullable's alias this does not work with structs containing classes
Bugzilla 7812: Segfault on invalid code during template match deduction with errors gagged
Bugzilla 7814: Regression(2.059head) ICE(tocsym.c) using scope(failure) within foreach-range
Bugzilla 7815: Mixin template forward reference (?) regression
Bugzilla 7820: regression(DMD 2.059head) Wrong error on forward reference to 'front' with -property switch
Bugzilla 7823: Can't use a struct initializer to initialize a nested enum used as a default function argument initializer
Bugzilla 7826: [D2 Beta] Cannot use getHash in toHash without a warning
Bugzilla 7843: Regression(2.059 beta): Informational warning fails to produce executable
Bugzilla 7857: File#write formats enum as a boolean.
Bugzilla 7858: __traits(getOverloads) returns incorrect symbol
Bugzilla 7859: Crash on invalid alias template parameter type
Bugzilla 7861: Segfault during __error propagation with self-referencing module
Bugzilla 7862: Accepts-invalid template forward reference bug related to derivedMembers
Bugzilla 7868: derivedMembers/static if regression
Bugzilla 7869: Cannot format pointer of struct has toString member function
Bugzilla 7871: RangeViolation with findSplitBefore
Bugzilla 7873: [2.059 beta] IFTI with inout does not properly match template parameter if called from inout function for pointers
Bugzilla 7886: derivedMembers infinite recursion
Bugzilla 7888: derivedMembers forward reference error with nested imports

Version D 2.058 Feb 14, 2012

New/Changed Features

Add new => lambda syntax.
Allow 1.userproperty syntax. NOTE: 1.f is no longer a float literal, add a 0.
Convert to -shared dmd switch instead of -dylib
Better use of XMM registers in OS X 32 bit target.
Add inline assembler support for AVX instructions (64 bit targets only).
Use of base class protection is now deprecated.
Added traits isVirtualMethod and getVirtualMethods.
Struct/class invariants are now implicitly const.
Major overhaul of std.regex module's implementation. Breaking change in std.regex.replace with delegate, use Captures!string instead of RegexMatch!string as delegate parameter.
As typedef has been deprecated, overloads of std.conv.to which use typedef have now been deprecated.
std.array.insert has been deprecated. Please use std.array.insertInPlace instead.
The overload of std.array.replace which replaces in place has been deprecated. Please use std.array.replaceInPlace instead.
The toISOExtendedString and fromISOExtendedString functions on SysTime, Date, TimeOfDay, and DateTime in std.datetime have been deprecated. Please use toISOExtString and fromISOExtString instead.
std.file.getTimesPosix has been deprecated. Please use std.file.getTimes instead.
The overloads for isDir, isFile, and isSymlink in std.file which take a uint have been deprecated. Please use attrIsDir, attrIsFile, and attrIsSymlink instead.

Druntime Bugs Fixed

Library Bugs Fixed

Bugzilla 4295: IID_IUnknown symbol undefined in phobos.lib
Bugzilla 7241: std.format can't read into array of dchar

DMD Bugs Fixed

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

Version D 2.057 Dec 13, 2011

New/Changed Features

Better use of XMM registers in 64 bit targets.
The invariant keyword as a synonym for immutable is now deprecated - use immutable instead
Add Mach-O 64 bit support for obj2asm and dumpobj
classes, interfaces, and exceptions are supported in CTFE
Bugzilla 3474: PATCH: Implement opDollar for struct and class indexing operations
Bugzilla 6572: Deprecate typedef
Major overhaul of std.regex module's implementation. Breaking change in std.regex.replace with delegate, use Captures!string instead of RegexMatch!string as delegate parameter.
As typedef has been deprecated, overloads of std.conv.to which use typedef have now been deprecated.
std.array.insert has been deprecated. Please use std.array.insertInPlace instead.
The overload of std.array.replace which replaces in place has been deprecated. Please use std.array.replaceInPlace instead.
The toISOExtendedString and fromISOExtendedString functions on SysTime, Date, TimeOfDay, and DateTime in std.datetime have been deprecated. Please use toISOExtString and fromISOExtString instead.
std.file.getTimesPosix has been deprecated. Please use std.file.getTimes instead.
The overloads for isDir, isFile, and isSymlink in std.file which take a uint have been deprecated. Please use attrIsDir, attrIsFile, and attrIsSymlink instead.
Bugzilla 2550: implicit conversions don't apply to template value parameter specialization
Bugzilla 3467: Non-int integral template parameters not correctly propagated
Removed top const from dynamic array types and pointer types in IFTI.

Druntime Bugs Fixed

Bugzilla 6909: incorrect definition of the OVERLAPPED struct in core.sys.windows.windows ?

Library Bugs Fixed

Unlisted bug: std.conv: Fix to!float("-0")
Unlisted bug: std.file broken on OS X x86_64 due to wrong stat64 declaration.
Bugzilla 2936: std.regex.match() short string optimization
Bugzilla 4765: std.math.modf always returns 0
Bugzilla 5193: SList cannot have struct elements that have immutable members.
Bugzilla 5620: Implicit conversion of RegexMatch to bool.
Bugzilla 5712: [patch] std.regex.replace disallows w/dstring
Bugzilla 6204: emplace() for classes accepts larger chunk but fails in array assignment
Bugzilla 6887: Regression of getopt
Bugzilla 6888: std.getopt.getopt: one-letter hash option causes range violation
Bugzilla 6935: struct with @disable this cannot make range
Bugzilla 6953: std.concurrency needs more documentation
Bugzilla 6973: static assert(isOutputRange!(OutputRange!int, int)) is false
Bugzilla 6976: GetLastError called as property
Bugzilla 6977: getErrno called as property in std.stdio
Bugzilla 6979: hasUnsharedAliasing cannot accept plural parameters
Bugzilla 6990: std.string.splitlines deprecation doc missing a word
Bugzilla 7000: missing import of std.stdio in std.regex?
Bugzilla 7039: Posix 2.057 Makefile error breaking 64bit build
Bugzilla 7040: Phobos must use "version/else version" blocks for proper documentation generation.
Bugzilla 7045: AssertError in std.regex on line 1573
Bugzilla 7055: to!float("INF2") == 2

DMD Bugs Fixed

Bugzilla 2095: covariance w/o typechecks = bugs
Bugzilla 2532: '=' does not give a boolean result
Bugzilla 2778: alias this + IFTI doesn't work.
Bugzilla 2856: static opIndex does not compile for a templated struct/class
Bugzilla 3990: Deferencing a dynamic array as pointer
Bugzilla 4047: [CTFE] class/struct heap allocation
Bugzilla 4401: auto functions cannot be inner functions
Bugzilla 4511: Contravariance problem
Bugzilla 4583: PIC code not working: EBX register set incorrectly
Bugzilla 5311: Pure is broken when accessing globals / static data through instance reference
Bugzilla 5364: optimizer kills high dword of -1
Bugzilla 5416: null should have a type of its own
Bugzilla 5899: auto-return function cannot match 'null' with reference type.
Bugzilla 6056: Type lookup problem in string mixins
Bugzilla 6077: CTFE: Cannot append null array to null array.
Bugzilla 6330: Cannot disable assignment to a struct.
Bugzilla 6354: Optimizer bug on x86_64: Bitshift optimized out when foreach and scope(failure) are used
Bugzilla 6416: [CTFE] Declaration static struct is not yet implemented in CTFE
Bugzilla 6479: spurious alias this with struct and mixin template
Bugzilla 6522: [CTFE] Problem with opAssign call in foreach(ref)
Bugzilla 6603: [CTFE] Can't call through a manifest constant function pointer
Bugzilla 6736: Regression(2.054): ICE (cgcod.c 1672) with alias this and certain structs
Bugzilla 6763: Using TypeTuple with (const/in/ref etc.) changes it forever
Bugzilla 6792: [CTFE] ICE with pointer cast of indexed array
Bugzilla 6800: [CTFE] dangerous pointer casts should be rejected
Bugzilla 6805: Can't use a type from opDispatch template
Bugzilla 6816: [CTFE] nested function can't access this
Bugzilla 6817: [CTFE] Error on interpreting inlined IfStatement
Bugzilla 6832: Can't test objects wrapped with alias this
Bugzilla 6836: map + UFCS = fail
Bugzilla 6837: alias this + UFCS = fail
Bugzilla 6851: [CTFE] Cannot deref pointer passed by argument
Bugzilla 6859: Segfault when abstract method uses with contract.
Bugzilla 6864: Const conversion should precedence over the shared one
Bugzilla 6865: inout matching removes shared qualifier
Bugzilla 6866: ICE(mtype.c): alias this and inout matching
Bugzilla 6867: inout and nested foreach loops
Bugzilla 6868: IsExp + incorrect static array type = error
Bugzilla 6870: type qualifiers behave inconsistently in combination with typeof
Bugzilla 6872: Breaking type parsing of shared(inout(int)[])
Bugzilla 6877: [XMM] regression, clobbered float value
Bugzilla 6879: The difference of between template matching and IsExp
Bugzilla 6881: [XMM] ICE with painted float
Bugzilla 6885: [CTFE] wrong code with dynamically allocated 2D array
Bugzilla 6886: [CTFE] ICE(interpret.c) new array with initializer
Bugzilla 6901: wrong error "override cannot be applied to variable" in CTFE forward reference
Bugzilla 6902: Different "pure nothrow int()" types
Bugzilla 6910: __traits(hasMember, "") does not work, if template has alias param
Bugzilla 6912: const(T)[] can be implicitly cast to inout(const(T)[])
Bugzilla 6919: [CTFE] Cannot get effect to local variable through its pointer
Bugzilla 6922: [TDPL] superimposing of const and immutable does not work correctly
Bugzilla 6927: Better @property management by chained functions
Bugzilla 6928: alias this, immutable and common type fail in presence of fields with indirections
Bugzilla 6929: [ICE] typeMerge crashes in presence of ambiguous alias this conversions
Bugzilla 6941: .stringof displays redundant storage classes
Bugzilla 6972: [CTFE] ICE with ubyte/=uint
Bugzilla 6994: Using explicit 'this' in template constraint causes an error
Bugzilla 6997: 64bit optimizer bug
Bugzilla 7004: Iterating tuple with index which explicitly typed as size_t causes an error
Bugzilla 7026: 64 bit optimizer bug
Bugzilla 7027: Struct member trySemantic() regression in DMD Git master
Bugzilla 7028: Fails to save FPU regs when executing finally block
Bugzilla 7072: [2.057 Beta] Assertion failure: '0' on line 145 in file 'mtype.c'
Bugzilla 7093: aliased type sometimes isn't resolved

Version D 2.056 Oct 26, 2011

New/Changed Features

add -gs compiler switch
Bugzilla 3194: invariant should be checked at the beginning and end of protected functions
Bugzilla 5399: Return the result of a nonvoid function in a void function
Bugzilla 6752: Add separate option to control stack frame generation
std.exception: enforce/enforceEx now can use in @safe pure function.
Added optional KeepTerminator param to std.string.splitLines.
Added std.string.outdent.
std.utf: More @safe and pure.
std.windows.registry now use *W functions in order to deal properly with Unicode.

Druntime Bugs Fixed

Bugzilla 5967: Mangling of ArgClose for variadic function is swapped
Bugzilla 6493: Source code for the doc of core.time points to std.datetime.
Bugzilla 6466: core.demangle incorrect demangling of variables

Library Bugs Fixed

Bugzilla 5522: std.range.zip fails on arrays of Object.
Bugzilla 6009: std/container disabled on freebsd/64
Bugzilla 6160: std.conv.to: Ignore _ to match the rest of D
Bugzilla 6181: assert fails in datetime.d while runining Phobos unittest
Bugzilla 6258: std.conv.to!real("-") fetches the front of an empty array.
Bugzilla 6275: Const values in tuples
Bugzilla 6288: std.conv.to removes const/immutable when converting a class
Bugzilla 6609: std.conv.parse!Integer should consider sign when radix == 10
Bugzilla 6634: std.path.globMatch throws wrong assertion
Bugzilla 6640: More formatting consistency between string and range of char
Bugzilla 6761: Strange behavior of RedBlackTree causing a dangling pointer
Bugzilla 6819: BigInt ^^ fails for some big numbers (powers)

DMD Bugs Fixed

Bugzilla 546: Error message for accessing a deprecated variable is doubled
Bugzilla 1339: Invariant/const-ness is broken by built-in array properties sort and reverse
Bugzilla 1891: Array-concatenation of T* and T*[] produces corrupted result
Bugzilla 1993: Error calling vararg delegate with null
Bugzilla 2315: DMD Stack Overflow on unwanted ctfe recursion
Bugzilla 2553: Excess attribute propagation for interfaces
Bugzilla 2361: delete is allowed on invariant references.
Bugzilla 2737: Nonsensical Error Message on Unsafe .idup
Bugzilla 2740: Template Mixins do not work as advertised
Bugzilla 2953: tuple.length rejected as a tuple parameter in a static foreach
Bugzilla 3069: Array literals do not implicitly cast to void[]
Bugzilla 3133: Compiler does not check that static array casts are legal
Bugzilla 3180: Covariance of delegates/function pointers
Bugzilla 3550: array.dup violates const/invariant without a cast.
Bugzilla 3659: Too much exegesis on opEquals
Bugzilla 3748: inout does not work properly
Bugzilla 4022: [CTFE] AA get
Bugzilla 4197: ICE(glue.c): error in forward-referenced in/out contract
Bugzilla 4206: type accepted as enum initializer
Bugzilla 4237: Typedefs of the same name cause initializer conflict
Bugzilla 4269: Regression(2.031): invalid type accepted if evaluated while errors are gagged
Bugzilla 4284: empty string[] alias lacks .length in a template
Bugzilla 5453: ICE(statement.c): invalid switch statement forward referenced by CTFE
Bugzilla 5696: Templates typetuple iteration
Bugzilla 5703: std.intrinsic. and core.bitop.bsf, bsr and bswap should be CTFE-able
Bugzilla 5886: Template this parameter cannot be made implicit, when other parameters are explicitly given
Bugzilla 5932: Internal error: s2ir.c 339
Bugzilla 6062: segv in dmd/64 with assoc array literals
Bugzilla 6073: Cannot pass __traits(parent, ...) as a template parameter if it is a module
Bugzilla 6084: Impossible to instantiate local template with TypeTuple-foreach iterator variable.
Bugzilla 6087: typeof(this) doesn't work outside member function
Bugzilla 6139: Duplicate error message on compile-time out of bounds array index
Bugzilla 6289: Make slices of const/immutable arrays mutable (but keep the elements const/immutable)
Bugzilla 6296: ICE(glue.c): invalid template instantiated in is(typeof()).
Bugzilla 6352: Regression(2.054) Implicit pure/nothrow/@safe messes up delegate arrays
Bugzilla 6360: @property is doubled in di files when used with auto
Bugzilla 6404: Cannot check ref-ness of auto ref parameter in template constraint
Bugzilla 6488: DMD compiler bug
Bugzilla 6518: break inside a static foreach inside a switch
Bugzilla 6529: writeln(const array of enums) too
Bugzilla 6584: ICE on large version number/debug level
Bugzilla 6596: Error message with not extern(C) function
Bugzilla 6599: Segfault: invalid expression in initializer
Bugzilla 6630: Assigning null to class with nested alias this class is misinterpreted
Bugzilla 6656: static alias this broken in 2.055
Bugzilla 6661: Templates instantiated only through is(typeof()) shouldn't cause errors
Bugzilla 6665: Regression(2.055) ICE(cg87.c): static double inside closure
Bugzilla 6672: [CTFE] ICE on compile time std.algorithm.sort
Bugzilla 6674: Regression(2.055) mixin and __traits(allMembers) generates incorrect result
Bugzilla 6675: Regression(2.054) ICE(glue.c) template parameter deduction with errors gagged
Bugzilla 6682: Template function that has lazy parameter is not inferred as pure
Bugzilla 6690: Using lazy parameter should be inferred as @safe
Bugzilla 6691: static constructor inside template cannot initialize immutable template members
Bugzilla 6693: [CTFE] Cannot set value to nested AA
Bugzilla 6695: typeof(this) does not take into account const/immutable attributes inside member functions
Bugzilla 6698: Regression(2.053): segfault with naked asm in inner function
Bugzilla 6700: Regression(2.053) using $ inside a slice of a tuple
Bugzilla 6719: "Error: out of memory" in parsing
Bugzilla 6721: [CTFE] Cannot get pointer to start of char[]
Bugzilla 6727: [CTFE] ICE(interpret.c): assignment from string literal.dup.ptr
Bugzilla 6733: Regression(2.054) ICE(cod2.c) pure nothrow func with side-effect parameters
Bugzilla 6739: [CTFE] Cannot set a value to an outer AA of a nested AA
Bugzilla 6746: static this() inside struct skipped upon static method call
Bugzilla 6749: [CTFE] problem with array of structs
Bugzilla 6751: [CTFE] ref argument of AA doesn't work
Bugzilla 6753: Regression(2.055beta) "Reinterpret" cast of array to a tail const one doesn't work inside @trusted
Bugzilla 6759: missing initialization in foreach with alias this
Bugzilla 6765: [CTFE]: AA.length doesn't compile when AA is null
Bugzilla 6769: [CTFE] AA.keys doesn't compile when -inline is used
Bugzilla 6770: inout is allowed on fields
Bugzilla 6773: inout variable should not be modifiable
Bugzilla 6775: [CTFE] foreach over an AA fails to compile
Bugzilla 6782: inout-correct range is not iterable using foreach with type deduction inside non-inout function
Bugzilla 6813: Yet another "cannot get frame pointer" error
Bugzilla 6822: New ubuntu linking rules prevent dmd from linking programs on Ubuntu 11.10
Bugzilla 6825: Regression(2.055+): Address of templated method incorrectly taken

Version D 2.055 Sep 4, 2011

New/Changed Features

Added dman
Add support for Mac OS X 10.7 Lion
Add protection to json output
Add SSE4.1 and SSE4.2 assembly instructions
Bugzilla 4375: Require explicit braces when 'else' is ambiguous
std.algorithm.copy now specializes on arrays for 10-80x improved performance.
std.path has been rewritten from scratch and has a completely new API.
std.utf.toUTFz allows you to get a zero-terminated string of any character type and of any type of mutability.
Added symlink and readLink to std.file for Posix systems.
Values for GDC and LDC were added to std.compiler.Vendor.
Added functions to std.bitswap for generically handling swapping endianness.
Added std.parallelism.TaskPool.workerIndex.
Added buffer recycling overload of std.parallelism.asyncBuf
std.math.tgamma, lgamma, erf, and erfc are now deprecated. The equivalent functions in std.mathspecial should be used instead.
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.
std.range: Added indexed and chunks
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.
std.string.tr has been updated so that it works with any string type.
std.conv.parse works for associative array and static array
std.format: Improvement of formatValue and unformatValue. They now works for associative array, consider element escaping, and treat range format spec more properly.
std.complex: added sin(), cos(), sqrt()
md5: 1.4X speedup

Druntime Bugs Fixed

Bugzilla 5967: Mangling of ArgClose for variadic function is swapped
Bugzilla 6493: Source code for the doc of core.time points to std.datetime.
Bugzilla 6466: core.demangle incorrect demangling of variables

Library Bugs Fixed

Unlisted bug: std.range.transversal should have length
Bugzilla 3890: Bad writeln of a nested struct
Bugzilla 4500: scoped moves class after calling the constructor
Bugzilla 4977: cannot use nothrow or pure with Rebindable
Bugzilla 5237: writefln doesn't respect Complex.toString
Bugzilla 5645: std.range.drop()
Bugzilla 5825: write is calling a deprecated function
Bugzilla 6040: std.cpuid and core.cpuid return different values for some methods
Bugzilla 6064: std.array.join is unnecssarily slow for strings
Bugzilla 6194: [GSoC] Destructor gets called on object before it is copied when calling writeln()
Bugzilla 6261: [2.054 beta regression] Regex cannot take a char[]
Bugzilla 6301: Cannot 'zip'/'retro'/'stride' etc. a range having 'ulong' length.
Bugzilla 6377: std.conv.to should check range when changing signedness
Bugzilla 6424: std.traits.hasElaborateAssign is limited
Bugzilla 6448: writef("%05d", BigInt) problem
Bugzilla 6514: CTFE dot product
Bugzilla 6587: std.parallelism's Task cannot handle immutable values
Bugzilla 6606: RefCounted doesn't work with unions due to use of format
Bugzilla 6608: Tuple field is not escaped

DMD Bugs Fixed

Bugzilla 1471: Linker error on template function. Error 42: Symbol Undefined ...
Bugzilla 1567: call to private super-constructor should not be allowed
Bugzilla 1684: offsetof does not work, adding cast is workaround
Bugzilla 1904: wrong protection lookup for private template functions
Bugzilla 2156: [] and null should be accepted where a compile-time string is required
Bugzilla 2234: __traits(allMembers) returns incorrect results for mixin and template alias members of an aggregate
Bugzilla 2245: Bug with overloaded, mixin template functions in classes
Bugzilla 2246: Regression(2.046, 1.061): Specialization of template to template containing int arguments fails
Bugzilla 2540: super can not be using in alias statement
Bugzilla 2634: Function literals are non-constant.
Bugzilla 2355: is() doesn't resolve aliases before template matching
Bugzilla 2579: Template function accepting a delegate with in argument doesn't compile
Bugzilla 2774: Functions-as-properties makes it impossible to get the .mangleof a function
Bugzilla 2777: alias this doesn't forward __dollar and slice op.
Bugzilla 2781: alias this doesn't work with foreach
Bugzilla 2787: Members found in an 'alias this' are not implicitly accessible in methods
Bugzilla 2941: Wrong code for inline asm because CPU type is set too late
Bugzilla 3268: can't compare pointer to functions when one is const
Bugzilla 3273: Regression(2.031): struct invariant + dtor fails to compile (no line number)
Bugzilla 3512: dchar iteration over string in CTFE fails
Bugzilla 3661: ^^ not supported in array operations.
Bugzilla 3797: Regression(2.038): Implicit conversion between incompatible function pointers
Bugzilla 4021: [CTFE] AA rehash
Bugzilla 4099: Inconsistent behaviour of ++/-- when mixing opUnary and 'alias this'.
Bugzilla 4444: Cannot index built-in array with expression tuple
Bugzilla 4460: Regression(2.036) ICE(e2ir.c) when compiling foreach over associative array literal
Bugzilla 4682: [CTFE] Run-time Vs Compile-time of int.min % -1
Bugzilla 4773: Rebindable should be castable to bool
Bugzilla 4837: ICE(constfold.c) CTFE with >>>=
Bugzilla 4984: Recursive template constraint results in dmd running out of memory
Bugzilla 5046: Wrong type of implicit 'this' in struct/class templates
Bugzilla 5081: Pure functions as initializers for immutable structures
Bugzilla 5188: alias this and compare expression generates wrong code
Bugzilla 5239: optimizer misreports an used before set error
Bugzilla 5373: Regression (2.051) CTFE and std.string.replace() causes "Bad binary function q{a == b}..
Bugzilla 5440: ICE(template.c): when struct AssociativeArray is missing from object.d
Bugzilla 5585: bad debug line number info for return statements with enumerator expressions
Bugzilla 5745: Missing error line number with lazy argument
Bugzilla 5750: Allow pure functions to have lazy arguments
Bugzilla 5777: Move semantics require full spec NRVO
Bugzilla 5785: Lexing or Parsing issue with UFCS
Bugzilla 5790: 'Error: variable result used before set' when -release -inline -O
Bugzilla 5799: Address-of operator fails on nested conditional operator expression
Bugzilla 5936: Regression(2.050): Segfault when forward-referencing pure auto-return member function with parameter.
Bugzilla 5953: Too many trailing commas are accepted
Bugzilla 6097: SSSE3 not working with MMX instructions
Bugzilla 6215: LLVM-compiled DMD segfaults due to mem.c alignment issues
Bugzilla 6220: Regression(2.053) static foreach over a string[] no longer produces directly usable strings
Bugzilla 6228: Regression(2.053) ICE(e2ir.c) on {auto x = (*ptr) ^^ y} with const integer types
Bugzilla 6230: Member functions can no longer be weakly pure
Bugzilla 6250: [CTFE] Crash when swapping two pointers to arrays.
Bugzilla 6265: Pure-inference failed when calling other pure functions
Bugzilla 6270: XMMREGS not preserved on indirect function call
Bugzilla 6276: [CTFE] Strange behavior of using ~= operator twice
Bugzilla 6280: [CTFE] Cannot put 'in' expression of AA in an 'if' condition
Bugzilla 6281: [CTFE] A null pointer '!is null' returns 'true'.
Bugzilla 6282: [CTFE] ICE when dereferencing a pointer to reference type from 'in' of an AA
Bugzilla 6283: [CTFE][Regression 2.054] Failed to assign to AA using a constness-changed array as key
Bugzilla 6284: [Regression 2.054] 'pure' does not work with 'with' statement
Bugzilla 6286: Regression(2.054): Static arrays can not be assigned from const(T)[N] to T[N]
Bugzilla 6293: [Regression 2.054] The expression x.y makes the function impure when the 'x' part is not just a variable
Bugzilla 6295: [Regression 2.054] Segfault in checkPurity() of template value parameter
Bugzilla 6306: Regression(2.054): [CTFE] Strange behavior of indirect recursive call in CTFE
Bugzilla 6308: Destruction of temporaries on exception causes unhandled access violation
Bugzilla 6316: Regression(2.054): Class downcast is rejected in @safe code
Bugzilla 6317: ICE on struct literal of nested struct
Bugzilla 6331: [CTFE] Cannot evaluate SliceExp on if condition
Bugzilla 6337: [CTFE] ICE when touching member variable of struct during CTFE
Bugzilla 6344: [CTFE] Assertion Failure in interpret.c when create an empty slice from null pointer
Bugzilla 6351: Regression(2.054) Segfault: Vararg delegate as template param
Bugzilla 6355: Template constructor cannot initialize non-mutable field
Bugzilla 6366: alias this doesn't work with foreach range.front
Bugzilla 6369: alias this doesn't work with initializer
Bugzilla 6374: [CTFE] Cannot subscript using pointer to array
Bugzilla 6375: [CTFE] Segfault when using std.array.appender with an initial array
Bugzilla 6386: [CTFE] ICE on pointer casting
Bugzilla 6389: Segfault(dsymbol.c): deprecated @disable
Bugzilla 6399: [CTFE] struct member array.length -= x doesn't work, while array[0..$-x] works
Bugzilla 6404: Cannot check ref-ness of auto ref parameter in template constraint
Bugzilla 6418: [CTFE] Cannot call a struct member function with name 'length'.
Bugzilla 6420: [CTFE] ICE on dereference-assigning to a pointer casted from a literal
Bugzilla 6429: Nested function error in reduce
Bugzilla 6433: Meta-Bug AA type propagation
Bugzilla 6434: opDispatch must be considered before alias this.
Bugzilla 6491: Fully qualified values in default arguments of non-template functions are generated with an extra 'module' keyword
Bugzilla 6499: [GSoC] Destructor not called on object returned by method.
Bugzilla 6505: Wrong code for expression involving 8 floats, only with -O
Bugzilla 6508: alias this doesn't work with AssignExp rhs
Bugzilla 6510: [CTFE] "internal error: illegal stack value" when compiled with -inline
Bugzilla 6511: [CTFE] Array op gives wrong result
Bugzilla 6512: [CTFE] new T[][] doesn't work
Bugzilla 6516: Regression(2.055 beta) [CTFE] ICE(constfold.c) involving new dchar[]
Bugzilla 6517: [CTFE] ptr++ doesn't work but ++ptr does
Bugzilla 6546: alias this + IdentityExpression doesn't work
Bugzilla 6556: ICE for ImportStatement in DebugStatement
Bugzilla 6558: [CTFE] UTF-decoding foreach gives wrong index (1-indexed)
Bugzilla 6561: alias this + undefined symbol should cause error
Bugzilla 6563: wrong code when using at least 8 XMM regs
Bugzilla 6577: 'Cannot initialize member' error line number
Bugzilla 6601: Regression(2.053): CTFE segfault taking address of function template
Bugzilla 6602: Invalid template instantiations leaked by is(typeof())/__traits(compiles, )/Type::trySemantic

Version D 2.054 Jul 10, 2011

New/Changed Features

Implement @safe
Implement @property
Automatic inference for @safe, pure, nothrow
Allow labelled break and continue in CTFE
Warn about switch case fallthrough
Pointers are now supported in CTFE
Heap-allocated structs are now supported in CTFE
Added SSSE3 instructions to inline assembler
Change from warning to deprecated: non-final switch statements must have a default statement
Change from warning to deprecated: function is hidden by function
Add warning about switch case fallthrough
Add warning about calling pure nothrow functions and ignoring the result
Allow associative arrays with key of type bool
Added inference for purity and safety
Change win32 dmd to not emit a map file unless asked for with -map
Added -property switch
Bugzilla 5823: @property call syntax restriction not implemented
Added core.sys.posix.netdb
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.
std.array.insertInPlace supports inserting of multiple ranges/elements in one go
Added std.array.uninitializedArray and std.array.minimallyInitializedArray
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.
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.
std.ctype has been scheduled for deprecation. std.ascii has been added to replace it.
Major performance improvements for std.algorithm.sort
std.string.atoi has been removed; replace it with std.conv.to!int
Switched to using posix.mak instead of various .mak files

Druntime Bugs Fixed

Bugzilla 4323: std.demangle incorrectly handles template floating point numbers
Bugzilla 5272: Postblit not called on copying due to array append
Bugzilla 5956: Undocumented mangling of struct value
Bugzilla 6135: Thread/GC interaction bug on OS X

Library Bugs Fixed

Bugzilla 2108: regexp.d: The greedy dotstar isn't so greedy
Bugzilla 3136: Incorrect and strange behavior of std.regexp.RegExp if using a pattern with optional prefix and suffix longer than 1 char
Bugzilla 3457: rdmd fails silently in a particular setup where the compiler is not the expected
Bugzilla 3479: writef/writefln: positional precision not working
Bugzilla 3564: Rdmd failing to link external C libraries
Bugzilla 3752: File.byLine fetches lines in a confusing manner
Bugzilla 4367: std.regex: Captures is not a random access range
Bugzilla 4574: std.regex: breaks with empy string regex
Bugzilla 4608: std.string.chomp documentation mismatch implementation
Bugzilla 5019: In std.regex, empty capture at end of string causes error
Bugzilla 5059: String assignment in foreach loop breaks immutability
Bugzilla 5458: scope for function parameters is not documented
Bugzilla 5511: std.regex optional capture with no-match cause error
Bugzilla 5598: rdmd does not fail on invalid filename
Bugzilla 5673: Add lookahead and forgetful matching support std.regex
Bugzilla 5705: Swapping identical struct with hasElaborateAssign causes "overlapping array copy" exception
Bugzilla 5836: std.typetuple.staticIndexOf's example code missing %s in call to writefln
Bugzilla 5857: std.regex (...){n,m} is bogus when (...) contains repetitions
Bugzilla 5869: std.thread needs to be removed
Bugzilla 6026: DLL example needs update due to missing core.dll_helper
Bugzilla 6076: regression, std.regex: "c.*|d" matches "mm"
Bugzilla 6101: Documentation for dead modules still distributed with DMD
Bugzilla 6113: singletons in std.datetime are not created early enough
Bugzilla 6193: Appender.clear() functionality or documentation

DMD Bugs Fixed

Bugzilla 693: 'this' can't be used as an alias parameter for a mixin
Bugzilla 1373: typeof(func).stringof fails when func has parameters.
Bugzilla 1411: ref Tuple should transform to Tuple of ref's
Bugzilla 1570: Wrong return for address operator
Bugzilla 2180: filename error with #line
Bugzilla 2521: Not possible to return immutable value by ref
Temp destructors now called if exception is thrown
Bugzilla 2625: Creating new struct with literal bypasses immutability of members if struct is in array
Bugzilla 3147: Incorrect value range propagation for addition
Bugzilla 3359: Cannot parse pure/const/immutable functions with inferred return type
Bugzilla 3445: partial fix
Bugzilla 3511: ref return property confused with property setter
Bugzilla 3632: modify float is float to do a bitwise compare
Bugzilla 3688: Can't have declaration with assignment to const/immutable inside if condition
Bugzilla 3722: A method without an in contract should always succeed, even if overridden
Bugzilla 3799: isStaticFunction trait evaluates to true for non-static nested functions
Bugzilla 4031: Should be able to access const value-type globals from pure functions
Bugzilla 4040: const/immutable on the right in auto return class methods
Bugzilla 4063: [CTFE] key not found in AA gives bad error message
Bugzilla 4065: [CTFE] AA "in" operator doesn't work
Bugzilla 4107: Duplicate documentation for member function templates
Bugzilla 4132: pointer arithmetic accepted in @safe functions
Bugzilla 4170: Missing line number on compile-time array index
Bugzilla 4258: "auto ref" doesn't work in one or more cases
Bugzilla 4448: [CTFE] labeled break doesn't work in CTFE
Bugzilla 4494: ICE(cod1.c) Array literal filled with results of void function
Bugzilla 4633: typeof({return 1;}()) declaration fails if inside main
Bugzilla 4661: Array Literal Incompatible Type Error Msg Should Include Line Number
Bugzilla 4706: Overloading auto return w/ non-auto return = strange error msg
Bugzilla 4745: Non-uniform handling of commas in static initialization of structs
Bugzilla 4885: Uninitialize Pointers Allowed in @safe code
Bugzilla 4910: [CTFE] Cannot evaluate a function that has failed at once
Bugzilla 4963: ICE(type.c:320) for struct append where T.sizeof < 3
Bugzilla 4969: nothrow check can't handle multiple catches
Bugzilla 5088: Cannot cast const(int) to long in @safe function
Bugzilla 5258: [CTFE] Stack overflow with struct by ref
Bugzilla 5284: Array ops punch through const system
Bugzilla 5327: Creating new struct with literal bypasses immutability of members of members of the struct
Bugzilla 5396: [CTFE] Invalid code with nested functions in CTFE
Bugzilla 5415: @Safe functions not working
Bugzilla 5497: -- now produces error message instead of wrong code
Bugzilla 5551: opUnary-opBinary conflict
Bugzilla 5574: Struct destructor freaks out when an array of struct with single element is instantiated inside a class
Bugzilla 5615: [CTFE] std.string.indexOf broken at compile time
Bugzilla 5633: [CTFE] ICE(constfold.c): is expression with struct, struct pointer, array literal...
Bugzilla 5657: Temporary object destruction
Bugzilla 5659: Conditional operator, array literal, and std.traits.CommonType return a wrong common type
Bugzilla 5676: [CTFE] segfault using tuple containing struct that has opAssign
Bugzilla 5682: [CTFE] Silently wrong result possibly related to operator overloading and expression order
Bugzilla 5693: Segfault with address of template struct opCall
Bugzilla 5708: [CTFE] Incorrect string constant folding with -inline
Bugzilla 5771: Template constructor and auto ref do not work
Bugzilla 5819: DMD doesn't error/warn about illegal asm for 64bit mode
Bugzilla 5845: Regression(2.041) [CTFE] "stack overflow" with recursive ref argument
Bugzilla 5856: overloading on const doesn't work for operator overload
Bugzilla 5859: Declaration inside if condition doesn't call destructor
Bugzilla 5861: Wrong filename in error message when an invalid delegate in a template parameter is typeof()-ed
Bugzilla 5885: wrong codegen for OPu32_d
Bugzilla 5897: unrelated struct type casting should ignite construction
Bugzilla 5936: Invalid code with nested functions in CTFE
Bugzilla 5946: failing lookup 'this' from function in template
Bugzilla 5954: [CTFE] enum structs with ctor
Bugzilla 5959: Return by reference with nested function should be allowed
Bugzilla 5962: Template function declaration with prefixed storage class and auto occurs conflict
Bugzilla 5963: iasm does not accept 64bit integer literal
Bugzilla 6001: [CTFE] ICE(interpret.c) mutating ref array
Bugzilla 6015: [CTFE] Strange behavior of assignment appears in a situation
Bugzilla 6049: [CTFE] Array literals of structs with invariant() are wrong
Bugzilla 6052: [CTFE] Struct elements in an array are treated like reference type
Bugzilla 6053: [CTFE] Two ICEs involving pointers (dereference and assign; pointer variable on stack)
Bugzilla 6054: [CTFE] ICE when returning a returned compile-time associative array containing a key of an idup-ed array literal
Bugzilla 6059: Incompatible types in array literal shows __error and error
Bugzilla 6072: [CTFE] Regression(git master): Cannot declare variable inside an 'if' condition
Bugzilla 6075: Cannot set value to associative array from a weakly-pure function when the value type has a (pure) opAssign
Bugzilla 6077: [CTFE] Cannot append null array to null array.
Bugzilla 6078: [CTFE] ICE on foreach over array struct member which is null
Bugzilla 6079: [CTFE] Array index out of bound detection is off-by-one
Bugzilla 6090: DDoc parenthesis escape issues.
Bugzilla 6100: [CTFE] Regression: struct return values wrong if used in array initializer
Bugzilla 6109: 'nothrow' does not check slice indices
Bugzilla 6111: Escaping reference to local variable not detected
Bugzilla 6119: Assertion failure: '0' on line 1118 in file 'glue.c'
Bugzilla 6120: [CTFE] ICE on calling constructor of template struct with -inline in function/delegate literal.
Bugzilla 6123: [CTFE] Cannot call a template member method inside delegate/function literal with -inline.
Bugzilla 6137: [CTFE] Foreach on semantically wrong initialized array crashes the compiler
Bugzilla 6145: Meaningless second error message for complex size of static array
Bugzilla 6150: runnable/testsocket.d
Bugzilla 6158: winsamp and dhry samples need an update
Bugzilla 6161: iasm opcode family Jcc use absolute address instead of relative for functions
Bugzilla 6164: [CTFE] Local arrays in a recursive local function behave funny
Bugzilla 6198: [GSoC] ICE(e2ir.c) With circular import
Bugzilla 6229: %= and /= no longer work on char type
Bugzilla 6230: Member functions can no longer be weakly pure
Bugzilla 6234: 64-bit array append generates inline code to copy new data, but does not call postblit
Bugzilla 6241: test sdtor.d on osx not catching
Bugzilla 6242: Disallow inoperant "in" contracts
Bugzilla 6264: ICE on testing opSlice in static if
Bugzilla 6267: Can't increment alias this'd struct from ref return
Bugzilla 6279: Regression(2.054 beta): array-vararg with pointer type not working in safe code

Version D 2.053 May 12, 2011

New/Changed Features

Added 64 bit tools to Linux
Added FreeBSD support
Renamed linux/bin to linux/bin32, added linux/bin64
osx/lib32 renamed back to osx/lib
Added some gc benchmark apps
Move std.intrinsic to core.intrinsic
Implemented exception chaining, as described in TDPL for Posix.
Added parent to __traits for QtD support
Allow impure code inside debug conditionals
Added cmpxchg16b, 64 bit bswap and movq instructions to internal assembler
Added bindings for libcurl: etc.c.curl
Added std.net.isemail
Added std.parallelism
Added support for positional parameter intervals, e.g. %1:3$s prints the first three parameters using the 's' format specifier
Added findSplit, findSplitBefore, findSplitAfter to std.algorithm; improved walkLength
Improved online documentation for std.algorithm
Added roundRobin, takeOne, and takeNone to std.range; improved stride
Added unsigned to std.traits
Removed std.iterator. Use either std.range.ElementType or std.range.ElementEncodingType depending on what you're trying to do.
Bugzilla 2656: Remove octal literals
Bugzilla 4097: Error: can only declare type aliases within static if conditionals
Bugzilla 4360: Allow intrinsics in core.bitop to operate as intrinsics
Bugzilla 4833: dmd -od doesn't make it to optlink's command line for map files

Druntime Bugs Fixed

Bugzilla 5612: core.cpuid not implemented on 64
Bugzilla 1001: print stack trace (in debug mode) when program die
Bugzilla 5847: Threads started by core.thread should have same floating point state as main thread

Library Bugs Fixed

Bugzilla 4644: assertExceptionThrown to assert that a particular exception was thrown
Bugzilla 4944: Missing tzname even though we have tzset
Bugzilla 5451: Three ideas for RedBlackTree
Bugzilla 5474: unaryFun byRef is borked for custom parameter name
Bugzilla 5485: TLS sections handled incorrectly in FreeBSD
Bugzilla 5616: std.datetime: not cross-platform
Bugzilla 5654: BigInt returns ZERO with strings of single digit number with leading zeros
Bugzilla 5661: std.algorithm.move does not work on elaborate struct
Bugzilla 5731: std.datetime.SysTime prints UTC offsets backwards
Bugzilla 5761: std.datetime: Date.this(int day) conversion fails for Dec 30 of leap years
Bugzilla 5780: [patch] std.traits.hasIndirections incorrectly handles static arrays
Bugzilla 5781: std.datetime: On Windows, times off by one hour in some years due to DST rule changes
Bugzilla 5794: std.datetime StopWatch (and perhaps benchmark) examples need a small fix
Bugzilla 5928: Bigint modulo problem -- critical wrong-code bug

DMD Bugs Fixed

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

Version D 2.052 Feb 17, 2011

New/Changed Features

64 bit support for Linux
Implemented exception chaining, as described in TDPL. Currently Windows-only.
std.random: Added Xorshift random generator
Support HTML5 entities
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.
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.

Bugs Fixed

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

Version D 2.051 Dec 21, 2010

New/Changed Features

Added std.mathspecial, containing mathematical Special Functions
std.base64: Replaced. Boost License, Performance improvement, Range support. Function signature changed from 'encode' to 'Base64.encode'
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
std.exception: Added pure and nothrow to assumeUnique
std.utf: Removed UtfError class and toUTF* shortcut functions for validation. Added pure, nothrow, @safe and @trusted attributes. count function supports dchar
Both druntime and phobos now build successfully with dmd -m64. Still somewhat behind dmd1, very little executes correctly still.

Bugs Fixed

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

Version D 2.050 Oct 29, 2010

New/Changed Features

added talign() and argTypes() to TypeInfo
Upgrade zlib support to zlib 1.2.5
std.stdio: Added ByChunk. This struct is a InputRange like ByLine. File.byChunk returns ByChunk
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.
Bugzilla 4888: Heavy reliance on Bug 3534 in Phobos range usage
Bugzilla 4987: C function pointer syntax needs to be deprecated
std.typecons: Several improvements to the Tuple struct template:
- Tuple members are now accessible with the syntax a[0], a[1] etc.
- Eliminated an internal union. See Bugzilla 4421 and Bugzilla 4846.
- Worked around Bugzilla 4424. Got opAssign back.
- Made Tuple.slice!(from, to) to preserve field names if any.
- Added isTuple!(T) template.
std.algorithm: changed filter() such that filter is curryable
std.algorithm: Added function balancedParens
std.typecons: Deprecated defineEnum
Added relaxed purity checking rules.

Bugs Fixed

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

Version D 2.049 Sep 13, 2010

New/Changed Features

std.algorithm: reduce now works with non-range-based iteration, such as opApply.
std.numeric: Added FFT.
std.path: Changed sep, altsep etc. to manifest constants (enum).
std.process: Added environment, an AA-like interface for environment variables.
std.range: Iota, Stride, Transversal, FrontTransveral now support slicing where possible.
std.range: Added support for moveFront() and assignable elements in several higher-order ranges.
std.range: Added Lockstep, hasLvalueElements.
std.range: Added virtual function-based wrappers (InputRangeObject, OutputRangeObject) for when a binary interface to a range is required.
std.typecons: Added convenience functions for Rebindable.
std.traits: Added isAssignable, isIterable, ForeachType, isSafe, isUnsafe, EnumMembers.
std.traits: hasLocalAliasing, hasLocalObjects and hasLocalRawAliasing are now hasUnsharedAliasing, hasUnsharedObjects and hasUnsharedRawAliasing. Aliases to the old names are included for now for backwards compatibility.
std.typetuple: Added anySatisfy.
std.array: Modified Appender's interface to fix memory issues. Note that appending via ~= and using appender on the same array will not interleave anymore.
Bugzilla 2477: Trailing comma in array literal sometimes accepted, sometimes not

Bugs Fixed

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

Version D 2.048 Aug 8, 2010

New/Changed Features

std.complex: New Complex.toString() syntax.
std.string: icmp() now works with all built-in string types.
Bugzilla 4077: Bugs caused by bitwise operator precedence
Bugzilla 4080: Patch for building dynamic libraries on Mac OS X

Bugs Fixed

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

Version D 2.047 Jun 11, 2010

New/Changed Features

Changed "op=" to just "op" for template argument to opOpAssign
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().
std.array: Added implementation of save() for T[]s.
std.concurrency: Eliminated spurious unittest stdout messages.
std.container: Added.
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.
std.file: Replaced exception upon out-of-memory error with assert(0).
std.functional: toDelegate now accepts callable(function pointers, delegates and objects implement opCall)
std.path: Made basename() generic in string type.
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.
std.regex: Qualified indexOf with std.algorithm.
std.regexp: Qualified indexOf with std.algorithm.
std.stdio: Added an error message to enforce() in rawRead().
std.string: Improved indexOf(), tolower(), splitter(), chomp().
std.traits: Added templates to get compile-time information about functions.
std.typecons: Added AutoImplement.
std.utf: Eliminated decodeFront() and decodeBack() - they aren't needed since strings are bidirectional ranges.
Bugzilla 2008: Poor optimization of functions with ref parameters
Bugzilla 3793: Functions with static arrays as arguments are not inlined
Bugzilla 4296: Reduce parasitic error messages

Bugs Fixed

Bugzilla 1193: regression: "matches more than one template declaration" doesn't list the location of the conflicting templates
Bugzilla 1894: scope(exit) is ignored except in compound statements
Bugzilla 1941: missing line on inaccesable external private module member
Bugzilla 2127: inliner turns struct "return *this" from by-value into by-ref
Bugzilla 2276: Error message missing line number on array operation
Bugzilla 2546: Array Ops silently fail when no slice symbol is used.
Bugzilla 2738: Rebindable should work for interfaces.
Bugzilla 2835: std.socket.TcpSocket doesn't actually connect
Bugzilla 2881: x.stringof returns typeof(x).stringof when x is an enum
Bugzilla 3064: Invalid array operation accepted, generates bad code
Bugzilla 3088: std.xml.check() fails on xml comments
Bugzilla 3139: compiler dies "Error: out of memory" with case range
Bugzilla 3200: std.xml doesn't follow spec for Tag.text
Bugzilla 3323: Segfault or ICE(e2ir.c) using struct with destructor almost anywhere
Bugzilla 3398: Attributes inside a union screws data alignment
Bugzilla 3465: isIdeographic can be wrong in std.xml
Major improvements to CustomFloat, fixing Bugzilla 3520: std.numeric.CustomFloat horribly broken
Bugzilla 3538: Default value of alias template parameter is instantiated only once.
Bugzilla 3547: for option -od for relative path the path is added twice
Bugzilla 3548: ICE occurs when an array is returned from a function is incorrectly used in an array op expression.
Bugzilla 3604: extern(C) callable function with array parameters broken
Bugzilla 3651: mangleof broken for enums
Bugzilla 3653: Problem sorting array of Rebindable
Bugzilla 3658: Crashing on vector operations (Mac only)
Bugzilla 3662: Wrong compile error within struct constructor and C-style initializer
Bugzilla 3667: Regression(D2 only): broken out(result) in contracts
Bugzilla 3786: bug in std.string.removechars
Bugzilla 3854: Error on static initialization of arrays with trailing comma.
Bugzilla 3873: std.range.repeat should have popBack defined
Bugzilla 3876: std.range.Take back/popBack methods don't work correctly
Bugzilla 3880: std.regex functions with const/immutable Regex object
Bugzilla 4003: The result changes only with the order of source files.
Bugzilla 4045: [CTFE] increasing array length
Bugzilla 4052: [CTFE] increment from array item
Bugzilla 4056: Template instantiation with bare parameter not documented
Bugzilla 4073: core.cpuid crashes
Bugzilla 4078: [CTFE] Failed return of dynamic array item
Bugzilla 4084: Ignored missing main() closing bracket
Bugzilla 4109: writeln doesn't work with empty static array
Bugzilla 4143: fix warnings in dmd build
Bugzilla 4156: Segfault with array+=array
Bugzilla 4169: building dmd with a modern gcc produces a buggy compiler
Bugzilla 4175: linux.mak doesn't declare sufficient dependencies to support parallel builds
Bugzilla 4188: std.file.remove throws Exception on success
Bugzilla 4193: Regression 2.046, ICE(expression.c): initialising class member with const forward reference
Bugzilla 4202: Changset 1517 doesn't compile
Bugzilla 4207: std.cover.setDestDir does not work.
Bugzilla 4208: druntime should not depend on Phobos
Bugzilla 4212: DWARF: void arrays cause gdb errors
Bugzilla 4213: Strange behaviour with static void[] arrays
Bugzilla 4219: hasAliasing does not care about immutable
Bugzilla 4220: I cannot apply @safe to intrinsic operation(eg: std.math.sqrt)
Bugzilla 4228: std.array.replace contains 2 bugs
Bugzilla 4230: version(unittest)
Bugzilla 4231: Solitary opUnary Postincrement and Postdecrement user defined operators are broken.
Bugzilla 4242: ICE(module.c): importing a module with same name as package
Bugzilla 4249: std.regex fails to compile with debug=regex
Bugzilla 4252: [CTFE] No array bounds checking in assignment to char[] array
Bugzilla 4257: ICE(interpret.c): passing parameter into CTFE as ref parameter
Bugzilla 4259: Header generation omits leading '@' for properties
Bugzilla 4262: Header generation omits 'enum' for enum declarations
Bugzilla 4263: Header generation omits '@system' attribute
Bugzilla 4270: Missing line number in 'can only catch class objects' error message
Bugzilla 4300: BigInt * int doesn't work well

Version D 2.046 May 10, 2010

New/Changed Features

Add hints for missing import declarations.
Speed up compilation.
All length methods in Phobos are now a @property.
Bugzilla 1001: print stack trace (in debug mode) when program die

Bugs Fixed

Fix hanging problem on undefined identifiers.
Bugzilla 461: Constant not understood to be constant when circular module dependency exists.
Bugzilla 945: template forward reference with named nested struct only
Bugzilla 1055: union forward reference "overlapping initialization" error
Bugzilla 2085: CTFE fails if the function is forward referenced
Bugzilla 2386: Array of forward referenced struct doesn't compile
Bugzilla 3945: AssertExpression message should implicitly convert to const char[]
Bugzilla 4015: forward reference in alias causes error
Bugzilla 4016: const initializer cannot forward reference other const initializer
Bugzilla 4042: Unable to instantiate a struct template.
Bugzilla 4100: Break and continue to label should mention foreach
Bugzilla 4116: object.di does not match object_.d
Bugzilla 4146: Unavailable: core.sys.posix.sys.wait.waitid()
Bugzilla 4184: associative array with certain key types results in corrupt values during iteration

Version D 2.045 May 4, 2010

New/Changed Features

Bugs Fixed

Another try at fixing the Dwarf issues.

Version D 2.044 Apr 30, 2010

New/Changed Features

Improve spelling checking distance to 2.
Now all unittests are run, even if some fail
Many small improvements to error diagnostics and recovery

Bugs Fixed

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

Version D 2.043 Apr 6, 2010

New/Changed Features

.init property for static arrays is now an array literal
Improved speed of associative arrays
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.

Bugs Fixed

Fixed memory corruption problem with array appends
Bugzilla 122: DDoc newline behaviour produces suboptimal results
Bugzilla 1628: Ddoc produces invalid documentation for --- blocks
Bugzilla 2609: No documentation generated for destructor
Bugzilla 3808: Assertion Failure : Assertion failure: 'classinfo->structsize == CLASSINFO_SIZE' on line 870 in file 'toobj.c'
Bugzilla 3884: Segfault: defining a typedef with an invalid object.d
Bugzilla 3911: Associative array in CTFE crashes compiler
Bugzilla 3958: mixin(non-static method) crashes compiler
Bugzilla 3972: Regarding module with name different from its file name
Bugzilla 3984: Segfault(interpret.c): CTFE using struct constructor on a local static variable
Bugzilla 3986: Struct constructors bypass default initialization of member variables
Bugzilla 4002: dmd.conf and binary path in dmd -v output
Bugzilla 4004: DMD 2.042 CTFE regression with functions taking ref parameters
Bugzilla 4005: std.c.stdlib.exit in CTFE and more
Bugzilla 4011: Incorrect function overloading using mixins
Bugzilla 4019: [CTFE] Adding an item to an empty AA
Bugzilla 4020: [ICE][CTFE] struct postblit in CTFE
Bugzilla 4023: std.math.hypot() returns infinity when either argument is zero
Bugzilla 4027: Closures in CTFE generate wrong code
Bugzilla 4029: CTFE: cannot invoke delegate returned from function

Version D 2.042 Mar 19, 2010

New/Changed Features

Bugs Fixed

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

Version D 2.041 Mar 7, 2010

New/Changed Features

__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.
Interface member functions can now have contracts.
Added new operator overloading regime.
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.
Added -wi switch for Bugzilla 2567
Mixin template definitions should be preceded with mixin
Add !in operator.
Associative array contents can now be compared for equality
Use of length inside of [ ] is now deprecated, use $ instead
Added toDelegate() to std.functional to convert function pointers to delegates.
Implemented attributes for constructors.
Implemented qualifiers for struct literals, like immutable(S)(1,2,3)
Array equality can now be done with differing array element types.
Add simple spell checking.
Bugzilla 3378: [tdpl] ++x should be an lvalue
string, wstring are now bidirectional (not random) ranges
std.algorithm: defined move with one argument; levenshtein distance generalized to with all forward ranges; take now has swapped arguments
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
std.conv: changed the default array formatting from "[a, b, c]" to "a b c"
std.range: swapped order of arguments in take
std.stdio: added readln template
std.variant: now works with statically-sized arrays and const data
std.traits: added isNarrowString
The default type for [1,2,3] is now int[] rather than int[3].

Bugs Fixed

Bugzilla 2321: spec on inline asm can be misunderstood
Bugzilla 2463: No line number in "statement is not reachable" warning
Bugzilla 3029: Bug in array value mangling rule
Bugzilla 3306: bad function/delegate literal generated into header files
Bugzilla 3373: bad codeview debug info for long and ulong
Posix only, Bugzilla 3420: [PATCH] Allow string import of files using subdirectories
Bugzilla 3450: incorrect result for is (typeof({ ... }())) inside a struct
Bugzilla 3453: Linking order affects proper execution (Mac OSX only)
Bugzilla 3491: typeof((string[string]).init) == AssociativeArray!(string, string), doesn't implicitly convert to string[string].
Bugzilla 3500: super behaves differently with -inline
Bugzilla 3558: Optimizer bug results in false if condition being taken
Bugzilla 3582: core.stdc.ctype functions are not pure
Bugzilla 3619: Thread crash on exit
Bugzilla 3637: Array append patch to prevent stomping and to enhance thread-local append performance
Bugzilla 3644: Wrong UCHAR_MAX value in module core.stdc.limits
Bugzilla 3670: Declarator grammar rule is broken
Bugzilla 3689: Grammar does not allow const(int)
Bugzilla 3692: ICE(mtype.c) with associative arrays when std.variant is imported
Bugzilla 3695: __EOF__ token not documented
Bugzilla 3697: StructTemplateDeclaration and others missing constraint in rule
Bugzilla 3710: Typo in allMembers description?
Bugzilla 3736: corrupted struct returned by function with optimizations (-O)
Bugzilla 3737: SEG-V at expression.c:6255 from bad opDispatch
Bugzilla 3763: std.stdio.readlnImpl absurdly inefficient and overflows stack
Bugzilla 3768: reapeted quotes in ddoc.html
Bugzilla 3769: Regression: Segfault(constfold.c) array literals and case statements
Bugzilla 3775: Segfault(cast.c): casting no-parameter template function using property syntax
Bugzilla 3776: Wrong CHAR_MIN value in module core.stdc.limits
Bugzilla 3781: ICE(interpret.c): using no-argument C-style variadic function in CTFE
Bugzilla 3803: compiler segfaults
Bugzilla 3840: Jump to: section in the docs should be sorted

Version D 2.040 Jan 29, 2010

New/Changed Features

Clarification: function returns are not lvalues
Added shared static constructors/destructors, regular static constructors/destructors now deal with TLS
Add -map command line switch
Add @disable attribute
Delegates and function pointers may be used in CTFE
Delegate literals and function literals may be used in CTFE
Lazy function parameters may now be used in CTFE
Slicing of char[] arrays may now be used in CTFE
added static/final function implementations to interfaces
added getOverloads, identifier, and isStaticFunction traits.
ModuleInfo changed from class to struct
Bugzilla 3556: version(CTFE)
Bugzilla 3728: getOverloads and identifier traits

Bugs Fixed

Added TLS support for OSX
Bugzilla 47: Internal error: cg87 3316
Bugzilla 1298: CTFE: tuple foreach bugs
Bugzilla 1790: CTFE: foreach(Tuple) won't compile if Tuple contains string
Bugzilla 2101: CTFE: Please may I use mutable arrays at compile time?
Bugzilla 2066: to!(string)(int) into CTFE-compatible
Bugzilla 3488: Segfault(expression.c): enum declared with struct static initializer
Bugzilla 3535: struct constructors don't work in CTFE
Bugzilla 3552: ICE(mtype.c): declaring a variable called 'AssociativeArray' then using an AA.
Partial fix for Bugzilla 3569, stops the stack overflow
Bugzilla 3600: template instantiation with empty tuple
Bugzilla 3660: Templates and shared functions don't mix
Bugzilla 3668: foreach over typedef'd array crashes dmd
Bugzilla 3671: x^^3 gives wrong result when x is a floating-point literal
Bugzilla 3674: forward reference error with multiple overloads with same name
Bugzilla 3675: Regression: Struct literals cannot be initialized with another struct literal
Bugzilla 3687: Array operation "slice times scalar" tramples over memory
Bugzilla 3719: forward references can cause out-of-memory error
Bugzilla 3723: Regression: forward referenced enum
Bugzilla 3724: bug in Expression::arraySyntaxCopy (null pointer dereference on struct->union->struct)
Bugzilla 3726: Regression: ICE(mangle.c 81): struct forward reference with static this
Bugzilla 3727: lots of "deffering SomeStructName" messages when compiling
Bugzilla 3734: [patch] src/traits.c does not compile with gcc (Ubuntu 4.4.1-4ubuntu8) 4.4.1
Bugzilla 3740: Regression: class with fwd reference of a nested struct breaks abstract

Version D 2.039 Jan 1, 2010

New/Changed Features

Bugs Fixed

Bugzilla 3663: struct forward reference regresssion
Bugzilla 3664: struct forward declaration causes enum to conflict with itself

Version D 2.038 Dec 30, 2009

New/Changed Features

Added core.cpuid in Druntime
Bugzilla 3514: opApply should be the first-choice foreach iteration method.
Bugzilla 3577: Wrong precedence for opPow
Added auto ref functions
Added function template auto ref parameters
Added isRef, isOut and isLazy to __traits
Transporting return type from args to return type, see DIP2

Bugs Fixed

Bugzilla 45: Internal error: cgcod 1594
Bugzilla 46: Constant folding with long doubles
Bugzilla 282: Bizarre circular import nested name invisibility issue
Bugzilla 390: Cannot forward reference enum nested in struct
Bugzilla 400: forward reference error; no propety X for type Y (struct within struct)
Bugzilla 1160: enums can not be forward referenced
Bugzilla 1564: Forward reference error for enum in circular import
Bugzilla 2029: Typesafe variadic functions don't work in CTFE
Bugzilla 2816: Sudden-death static assert is not very useful
Bugzilla 3270: pure functions returning struct
Bugzilla 3443: Thread.thread_needLock() should be nothrow
Bugzilla 3455: Some Unicode characters not allowed in identifiers
Bugzilla 3458: int fsync(int) commented out in core.sys.posix.unistd
Bugzilla 3476: C-style initializer for structs must be disallowed for structs with a constructor
Bugzilla 3575: CTFE: member structs not initialized correctly
Bugzilla 3583: Unsigned right shift works the same as signed right shift.
Bugzilla 3584: DeclDef rule is missing entries
Bugzilla 3585: Duplicate clauses in EqualExpression and RelExpression rules
Bugzilla 3587: Aggregate rule references undefined Tuple
Bugzilla 3588: WithStatement rule references unspecified Symbol
Bugzilla 3589: BaseClassList and InterfaceClasses rules are incorrect, missing ','
Bugzilla 3590: FunctionParameterList rule is missing
Bugzilla 3591: TemplateIdentifier rule is misspelled
Bugzilla 3592: ClassTemplateDeclaration and FunctionTemplateDeclaration rules are unreferenced
Bugzilla 3593: IntegerExpression rule unspecified
Bugzilla 3594: AsmPrimaryExp rule references unspecified rules
Bugzilla 3595: Several rules are missing ':' after rule name
Bugzilla 3596: Need alias for using std.algorithm.remove
Bugzilla 3601: Debug and Release builds of DMD produce different object files
Bugzilla 3611: Enum forward referencing regression
Bugzilla 3612: ExpressionList is undefined
Bugzilla 3617: CTFE: wrong code for if(x) where x is int or smaller
Bugzilla 3621: implicit conversion to const rules need tightening
Bugzilla 3633: Optimizer causes access violation
Bugzilla 3641: alias shared T U does not work
Bugzilla 3645: manifest constant (enum) crashes dmd
Bugzilla 3647: non-function opDispatch crashes dmd

Version D 2.037 Dec 3, 2009

New/Changed Features

Conditional expressions ?: can now be modifiable lvalues.
The type inferred from an ArrayLiteral is now a dynamic array, not a static one.
Added support for op= for array.length
Array and associative array types are now determined by using ?: across all the elements, not just using the first one.
Array concatenation with elements now allows implicit conversion of the elements to the array element type.
No more comma operators allowed between [ ].
ClassInfo now merged into TypeInfo_Class.
Bugzilla 3379: [tdpl] Parameter names not visible in the if clause of a template
Bugzilla 3380: [tdpl] typeid(obj) should return the dynamic type of the object
Removed -safe command line switch, added -noboundscheck command line switch.
Bugzilla 3481: PATCH: opPow(), x ^^ y as a power operator
Added opDispatch
properties can only have 0 or 1 arguments
properties cannot be overloaded with non-properties
std.math: Added FloatControl, IeeeFlags for enabling floating-point exceptions.
std.math: Inverse trig functions are now pure nothrow.

Bugs Fixed

std.array: Fixed unlisted bug in array().
Bugzilla 111: appending a dchar to a char[]
Bugzilla 2664: OSX standard math functions are less accurate
Bugzilla 2802: VariantN.opCmp!(T) fails when T != VariantN
Bugzilla 2967: spec does not mention that inline asm is a valid "return" statement
Bugzilla 2977: std.random.unpredictableSeed() should use thread ID somewhere
Bugzilla 3115: >>> and >>>= generate wrong code
Bugzilla 3171: % not implemented correctly for floats
Bugzilla 3311: std.range.chain shouldn't have opIndexAssign if arguments aren't mutable
Bugzilla 3375: [tdpl] Ternary operator doesn't yield an lvalue
Bugzilla 3381: [tdpl] Incorrect assessment of overriding in triangular-shaped hierarchy
Bugzilla 3388: [tdpl] contracts should allow throw expressions
Bugzilla 3390: [tdpl] out(result) contract should not be able to rebind result
Bugzilla 3407: [tdpl] Compiling with -safe -release must keep all bound checks
Bugzilla 3433: [tdpl] Comparing structs for equality is not member-by-member
Bugzilla 3469: ICE(func.c): Regression. Calling non-template function as a template, from another module
Bugzilla 3478: "no effect in expression" error on return to void
Bugzilla 3494: Segfault(mtype.c) using typeof(return) inside an auto function
Bugzilla 3495: Segfault(typinf.c) instantiating D variadic function with too few arguments
Bugzilla 3496: ICE(cgelem.c, optimizer bug) cast(void *)(x&1)== null.
Bugzilla 3502: Fix for dropped Mac OS X 10.5
Bugzilla 3521: Optimized code access popped register
Bugzilla 3540: Another DWARF line number fix
Bugzilla 3551: nested struct => dmd adds a hidden pointer
Bugzilla 3553: ICE when a function argument defaults to __LINE__

Version D 2.036 Nov 5, 2009

New/Changed Features

Static arrays are now passed by value to functions rather than by reference
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.
std.ctype: Add pure to isalnum, isalpha, iscntrl, isdigit, islower, ispunct, isspace, isxdigit, isgraph, isprint, isascii, toupper.
std.date: Implementation change and unittest for isLeapYear and daysInYear. Made both pure as well.
std.encoding: Added function count().
std.md5: Added explicit pass-by-ref for fixed-size buffers.
std.numeric: Added gcd.
std.random: Added static checks for the parameters of the linear congruential generator.
std.range: Reinstated some unittests; fixed Cycle to work with the new fixed-size arrays.
std.typecons: Added alias 'expand' for Tuple.field.
std:utf: Added count function and changed the encode function to take fixed-size array by reference.
Bugzilla 3446: Rename float.min to float.min_normal

Bugs Fixed

std.range: Fixed unlisted bug in Transposed.
Problem with complicated array op expressions
Bugzilla 195: DDoc generates bad output when example contains "protected" attribute
Bugzilla 424: Unexpected OPTLINK Termination at EIP=0044C37B (too many fixups)
Bugzilla 1117: ddoc generates corrupted docs if code examples contain attributes with colons
Bugzilla 1812: DDOC - Unicode identifiers are not correctly marked.
Bugzilla 2694: alias pure nothrow XXX; is not pure nothrow!
Bugzilla 2862: ICE(template.c) using type tuple as function argument
Bugzilla 3035: cannot have const/invariant out parameter of type shared
Bugzilla 3102: Incorrectly matching type as shared (two cases with is expressions)
Bugzilla 3269: pure functions silently become nothrow
Bugzilla 3292: ICE(todt.c) when using a named mixin with an initializer as template alias parameter
Bugzilla 3349: typeid(shared(T)) generates wrong value
Bugzilla 3367: Regression: struct initialization no longer supports ctor overloads
Bugzilla 3397: Unintended function call to static opCall
Bugzilla 3401: Compiler crash on invariant + method overload
Bugzilla 3422: ICE(cgcod.c) Structs with default initializers bigger than register size cannot be default parameters
Bugzilla 3423: Destructor and postblit don't get copied to the header file when using -H
Bugzilla 3426: ICE(optimize.c): struct literal with cast, as function default parameter.
Bugzilla 3429: Core dump on passing template literal to member function.
Bugzilla 3432: ICE(e2ir.c): casting template expression

Version D 2.035 Oct 14, 2009

New/Changed Features

Use -X to generate JSON files.

Bugs Fixed

Fold in patch from Bugzilla 1170
Bugzilla 1534: Can't mix in a case statement.
Bugzilla 2423: Erroneous unreachable statement warning
Bugzilla 2826: failed assignment gives wrong line number
Bugzilla 3190: enum doesn't work as the increment in a for loop
Bugzilla 3316: Functions nested in a pure templated function cannot reference its local variables
Bugzilla 3352: RangeError in std.conv
Bugzilla 3385: `std.string.split` requires a mutable array
Bugzilla 3392: a cast of this to void in tango.core.Thread is not allowed

Version D 2.034 Oct 11, 2009

New/Changed Features

Bugs Fixed

Bugzilla 258: Undefined identifier error for circular import
Bugzilla 1140: ICE(cod1.c) casting last function parameter to 8 byte value
Bugzilla 1592: dmd fail to resolve class symbol when i put files in a package
Bugzilla 2687: ICE(statement.c): tuple foreach in an erroneous template.
Bugzilla 2773: ICE(go.c) array assignment through a pointer, only with -O.
Bugzilla 2829: ICE(expression.c) static array block-initialized in struct literal
Bugzilla 3006: ICE(e2ir.c, tocsym.c) template module using array operation
Bugzilla 3041: Array slices can be compared to their element type: bad codegen or ICE
Bugzilla 3042: Segfault on incorrect override
Bugzilla 3101: Stack overflow: declaring aggregate member twice with static if
Bugzilla 3119: Segfault(expression.c) template function overloads with function with same name in other module
Bugzilla 3174: ICE(mtype.c): Compiler crash or compiler error with auto returns and const / immutable / invarient / pure
Bugzilla 3176: Compiler hangs on poorly formed mixin in variadic template
Bugzilla 3261: compiler crash with mixin and forward reference
Bugzilla 3286: Default parameter prevents to resolve inter-module circular dependency
Bugzilla 3301: Undefined identifier error dependent on order of imports when a circular import is involved
Bugzilla 3325: ICE(func.c) function literal with post-contract
Bugzilla 3343: Crash by "auto main(){}"
Bugzilla 3344: ICE(e2ir.c) returning an invalid function from main()
Bugzilla 3357: ICE(cod1.c) using 'in' with a static char array as AA key
Bugzilla 3366: Segfault(declaration.c) variadic template with unmatched constraint
Bugzilla 3374: [tdpl] ICE(init.c): Associative array type not inferred

Version D 2.033 Oct 5, 2009

New/Changed Features

Phobos is now using the Boost 1.0 license
Compiler now detects some cases of illegal null dereferencing when compiled with -O
The result type of the typeid(type) is now the most derived TypeInfo class, rather than the TypeInfo base class
Bugzilla 2905: Faster +-*/ involving a floating-pointing literal
Improved performance of int-to-string conversion

Bugs Fixed

gdb stack trace should work now
Bugzilla 302: in/out contract inheritance yet to be implemented
Bugzilla 718: ICE(cgcod.c) with int /= cast(creal)
Bugzilla 814: lazy argument + variadic arguments = segfault
Bugzilla 1168: Passing a .stringof of an expression as a template value parameter results in the string of the type
Bugzilla 1253: array initializers as expressions are not allowed in const arrays
Bugzilla 1571: Segfault(class.c) const on function parameters not carried through to .di file
Bugzilla 1731: forward reference of function type alias resets calling convention
Bugzilla 2202: Error getting type of non-static member of a class
Bugzilla 2469: ICE(cod1.c) arbitrary struct accepted as struct initializer
Bugzilla 2697: Cast of float function return to ulong or uint gives bogus value
Bugzilla 2702: Struct initialisation silently inserts deadly casts
Bugzilla 2839: ICE(cgcs.c) with int /= imaginary
Bugzilla 2970: std.path.join with version(Windows)
Bugzilla 2998: ICE(expression.c) with floating point enum
Bugzilla 3049: ICE(cod4.c) or segfault: Array operation on void[] array
Bugzilla 3059: Nonsensical complex op= should be illegal
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
Bugzilla 3160: ICE(cgcod.c 1511-D1) or bad code-D2 returning string from void main
Bugzilla 3173: ICE(mtype.c) on wrong code (double to long to int conversion)
Bugzilla 3288: conv.d: using to with const int or long fails to compile.
Bugzilla 3300: std.string.toupper and tolower should be (const(char)[]), not string
Bugzilla 3304: Segfault using 'is' with a pointer enum.
Bugzilla 3305: Segfault(expression.c) with recursive struct template alias expressions
Bugzilla 3333: std.conv.to!(string, const int) error: cannot modify const
Bugzilla 3335: minor warning cleanups
Bugzilla 3336: ICE(glue.c) declaring AA with tuple key, only with -g
Bugzilla 3340: std.string.split(S1 s, S2 delim) still doesn't work for char[]
Bugzilla 3353: storage class of a member function is propagated to default arguments
(unlisted): std.algorithm: bug in reduce when passed const arguments
(unlisted): std.stdio: fixed documentation example
(unlisted): std.utf: fixed decodeFront and decodeBack

Version D 2.032 Sep 2, 2009

New/Changed Features

Improved exception message for assert(0) in Windows -release builds
Added support for:
```
a[i].var = e2
```
and:
```
a[] = e
```
in CTFE. (thanks, Don!)
Member functions can now be used in CTFE
Operator overloading can now be used in CTFE
Nested functions can now be used in CTFE
CTFE error messages now explain why the function could not be interpreted at compile time
synchronized member functions now implicitly typed as shared.
std.algorithm: added minPos
std.format: added raw specifier for reading
added File.byChunk
std.algorithm: added more unittests and checks for user-based comparison passed to topN
std.math: replaced std.c with core.stdc; improved approxEqual to work with ranges, not only numbers or arrays
std.range: defined Take.popBack whenever sensible; improved iota to accept negative ranges and steps

Bugs Fixed

Bugzilla 601: statement.html - Formatting/markup errors in BNF
Bugzilla 1461: Local variable as template alias parameter breaks CTFE
Bugzilla 1600: Functions taking only one array cannot be called with property syntax
Bugzilla 1604: Non-final method on final struct is too restrictive (closed with "invalid" advise)
Bugzilla 1605: break in switch with goto breaks in ctfe
Bugzilla 1616: std/metastrings.d
Bugzilla 1940: Phobos buildscripts do not work on x86_64
Bugzilla 1948: CTFE fails when mutating a struct in an array
Bugzilla 1950: CTFE doesn't work correctly for structs passed by ref
Bugzilla 1969: ICE(cod1.c) using undefined operator with one const operand
Bugzilla 1972: Foreach range statement breaks CTFE
Bugzilla 2150: cannot get values from const variant
Bugzilla 2277: array ops and const arrays incompatible
Bugzilla 2398: writef("%x") for a pointer is always uppercase
Bugzilla 2560: ICE(cod4.c) on invoking method that takes ref const struct parameter
Bugzilla 2564: CTFE: the index in a tuple foreach is uninitialized (bogus error)
Bugzilla 2569: static arrays in CTFE functions don't compile
Bugzilla 2575: gdb can not show code
Bugzilla 2587: std.process.shell doesn't work for win32
Bugzilla 2604: DW_TAG_module and GDB
Bugzilla 2665: ICE(cod4.c) on certain const struct function return types
Bugzilla 2784: Interfaces should be able to require type definitions (closed with "invalid" advise)
Bugzilla 2785: Interfaces should be able to require non-member functions (closed with "invalid" advise)
Bugzilla 2786: Interfaces should be able to require constructors (closed with "invalid" advise)
Bugzilla 2882: std.random.MersenneTwisterEngine without no seed
Bugzilla 2925: Destructor not called
Bugzilla 2937: postblit not called for foreach arg over array of structs
Bugzilla 2940: null is null cannot be evaluated at compile time
Bugzilla 2976: rename retreatN to retreat
Bugzilla 2979: Xml tags with only attributes return as without attributes ElementParser.parse
Bugzilla 2980: compiler error when writefln( uint )
Bugzilla 2987: D2 phobos BigInt opMul doesn't work correctly
Bugzilla 2988: Chain needs opIndexAssign.
Bugzilla 2989: std.typetuple: add support for any static tuples
Bugzilla 2992: (closed with "later" advise)
Bugzilla 2996: std.typetuple: add support for any static tuples
Bugzilla 3000: iota should work with floats
Bugzilla 3017: doc errors in std.range (on behalf of Steven Schveighoffer)
Bugzilla 3025: uniform(float,float) pops first, uniform(int,int) pops last
Bugzilla 3037: Off-by-one error in Stride.length
Bugzilla 3039: -vtls compiler flag not listed in man file
Bugzilla 3058: [CTFE] Cannot return out of foreach range statement
Bugzilla 3074: std.conv.to!(string)(int.min)
Bugzilla 3077: 3077 crash exiting main() without result code
Bugzilla 3087: std.range.retro.opIndex out of range
Bugzilla 3098: std.algorithm.reduce example can not compile
Bugzilla 3100: ICE(cast.c) struct with members is shared
Bugzilla 3132: std.string.split should be templated on mutable/const/immutable
Bugzilla 3148: syntax error using invariant
Bugzilla 3153: win32.mak tries to copy phobos.lib, gcstub.obj to nonexistent folder lib
Bugzilla 3162: can't fully use compile-time floats as template parameters
Bugzilla 3165: What kind of integer division does D use?
Bugzilla 3166: "positive" -> "non-negative" in modulo operator description
Bugzilla 3169: Segfault(cast.c) dividing ulong by int
Bugzilla 3170: Forward reference of nested class fails if outer class is not plain
Bugzilla 3183: Spec of align attribute needs work
Bugzilla 3184: std.algorithm.until should work like "find"
Bugzilla 3185: osx is not a directory (complains cannot read std/c/osx/socket.d)
Bugzilla 3186: corrections for http://www.digitalmars.com/d/2.0/dmd-osx.html
Bugzilla 3189: `std.conv.to` : check for a custom `to` method in classes/structs
Bugzilla 3192: asm in a anonymous delegate crash the compiler
Bugzilla 3195: `std.conv` pureness (closed with "later" advise)
Bugzilla 3196: Segfault(mtype.c) after almost any error involving a delegate literal
Bugzilla 3197: Minor fixes and additions to std.traits
Bugzilla 3199: sort(chain(...)) doesn't work in some cases
Bugzilla 3205: CTFE: $ cannot be used in lvalues
Bugzilla 3212: Error message says "mutable"; should say "immutable"
Bugzilla 3217: std.functional.binaryFunImpl doesn't support UDT with string functions , therefore neither does many std.algorithm functions
Bugzilla 3218: Performance of std.xml.encode must be improved
Bugzilla 3219: Inaccurate std.conv.to!(numeric)(numeric) error messages
Bugzilla 3224: std.random documentation bugs
Bugzilla 3229: No return or assert(0) at end of function
Bugzilla 3236: Postblit called but no matching destructor
Bugzilla 3239: std.conv.roundTo does not accept const/immutable/shared
Bugzilla 3240: std.numeric.findRoot only works with real
Bugzilla 3242: splitter does not handle input range made of a unique separator correctly
Bugzilla 3245: Easy bug fix available for disabled unit test code in std.encoding
Bugzilla 3246: ICE(init.c) using indexed array initializer on local array
Bugzilla 3249: sort and setIntersection on array of struct or class
Bugzilla 3253: DMD crashes on function pointer struct member initialization with function literal
Bugzilla 3255: final switch broken with -w switch
Bugzilla 3257: Spec is unclear describing string switch case labels
Bugzilla 3260: "Error: undefined identifier backend" when compiling 'write' with 'wchar'
Bugzilla 3264: -O causes wrong "used before set" error when using enum.
Bugzilla 3281: ICE(cod1.c) append returned struct to array
Fixed bug processing spaces in dmd's directory
Fixed assert failure on line 4823 in expression.c
Fixed OSX compile error on samples/d/dhry.d
std.format: fixed unlisted bug in documentation
std.random: uniform does not work when passed immutable data
std.range: fixed unlisted bug in Take.back
unlisted: made entropy work on const/immutable arrays

Version D 2.031 July 6, 2009

New/Changed Features

Renamed root directory \dmd to \dmd2
Use of with symbols that shadow local symbols is no longer allowed
Added final switch statements
Added case range statements
Implicit integral conversions that could result in loss of significant bits are no longer allowed.
Warning on no return expr; is now an error.
Bugzilla 3080: dmd should output compilation errors to stderr, not stdout
Bugzilla 3122: [patch] Adding support for fast and reliable build tools to the frontend
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.
std.array: added array function.
std.conv: added Shin Fujishiro's code for printing and parsing enumerated values.
std.ctype: made isupper and tolower pure.
std.date: changed signature of benchmark to return ulong[] instead of uint[].
std.demangle: changed it to use the snazzy switch statement with ranged labels.
std.random: added randomSample
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.
std.traits: added isSomeChar, isPointer.
std.typetuple: replaced indexOf with indexOfType, kept the old name as an alias that will be deprecated.
std.utf: improved error messages.

Bugs Fixed

Fix dmd crash on multicore Windows.
Fixed unlisted bug in std.algorithm.startsWith
Fixed unlisted bug in std.algorithm.topN
Fixed unlisted bug in std.algorithm.topNIndex (empty index made it crash)
Fixed unlisted bug in std.algorithm.setIntersection
Fixed unlisted bug in std.range.retro: retro'izing a range twice must return the original range
Bugzilla 106: template - mixin sequence
Bugzilla 810: Cannot forward reference template
Bugzilla 852: ICE(toir.c) using local class in non-static nested function in nested static function
Bugzilla 1343: Various errors with static initialization of structs and arrays
Bugzilla 1358: ICE(root.c) on Unicode codepoints greater than 0x7FFFFFFF
Bugzilla 1524: ICE(constfold.c) on using "is" with strings in CTFE
Bugzilla 1984: Assertion failure: 'e1->type' on line 1198 in file 'constfold.c'
Bugzilla 2323: ICE(cgcs.c): taking address of a method of a temporary struct
Bugzilla 2399: ICE(cgcod.c) on casting function to delegate
Bugzilla 2429: std.stream.File incorrect flag parsing and sharing mode
Bugzilla 2432: complex alias -> mtype.c:125: virtual Type* Type::syntaxCopy(): Assertion `0' failed.
Bugzilla 2603: ICE(cgcs.c) on subtracting string literals
Bugzilla 2843: ICE(constfold.c) with is-expression with invalid dot-expression in is-expression involving typeid
Bugzilla 2865: RandomCover not random
Bugzilla 2875: ICE(cgcod.c) setting delegate = &Struct.func
Bugzilla 2884: ICE: Assert: 'template.c', line 3773, 'global.errors'
Bugzilla 2888: [PATCH] speedup for float * 2.0
Bugzilla 2900: Array appending slowed drastically since integration of druntime
Bugzilla 2915: [Patch]: Optimize -a*-b into a*b
Bugzilla 2923: -O generates bad code for ?:
Bugzilla 2932: bad e_ehsize (36 != 52)
Bugzilla 2952: Segfault on exit when using array ops with arrays of doubles larger than 8 elements
Bugzilla 2974: Segfault(mtype.c) on auto function
Bugzilla 2981: Bad code generation for structs containing invariants
Bugzilla 2982: Assertion failure in function if() clause
Bugzilla 3003: Need to implicitly add () on member template function calls
Bugzilla 3014: ICE(template.c) instantiating template with tuple
Bugzilla 3016: Errors in the documentation of std.math.acos
Bugzilla 3026: Segfault with incomplete static array initializer
Bugzilla 3044: Segfault(template.c) instantiating struct tuple constructor with zero arguments.
Bugzilla 3071: nested func declaration parse problem
Bugzilla 3078: NaN reported as equal to zero
Bugzilla 3081: unaryFun can't be used to get element out of struct.
Bugzilla 3095: wc example for D2 doesn't compile
Bugzilla 3114: optlink failing on multicore machines
Bugzilla 3117: dmd crash by *1
Bugzilla 3121: recurrence does not generate the correct numbers
Bugzilla 3128: Internal error: ..\ztc\cod4.c 2737
Bugzilla 3130: Crashed with triple stars

Version D 2.030 May 11, 2009

New/Changed Features

added -vtls compiler switch
classic global storage now defaults to TLS (Thread Local Storage). This is a big change, see Migrating To Shared.
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.
std.array: Improvements to Appender. Now it works with string and other immutable-element arrays, and accepts ranges in put().
std.format: added raw specifier for reading
std.range: Added iota with two arguments. Added FrontTransversal and Transversal.
std.stdio: added File.byChunk
std.traits: Added isImplicitlyConvertible.
std.tuple: Added Tuple.opComp.
Folded in compiler changes by Unknown W. Brackets to support Solaris.
added .typeinfo to ClassInfo Bugzilla 2836: Navigate from ClassInfo to TypeInfo

Bugs Fixed

Fix instruction scheduler bug on Linux
unlisted: made std.numeric.entropy work on const/immutable arrays
Fixed several problems associated with thread local storage
Bugzilla 642: error: mixin "static this" into where it cannot be
Bugzilla 713: circular const definitions with module operator "." cause the compiler to segfault
Bugzilla 752: Assertion failure: 'e->type->ty != Ttuple' on line 4518 in file 'mtype.c'
Bugzilla 858: Forward reference to struct inside class crashes the compiler
Bugzilla 884: Segfault in recursive template
Bugzilla 934: Segfault taking mangleof a forward reference in a template.
Bugzilla 1011: illegal import declaration causes compile time segfault
Bugzilla 1054: regression: circular aliases cause segfaults
Bugzilla 1061: "asm inc [;" segfaults compiler.
Bugzilla 1305: Compiler hangs with templated opCmp returning templated class
Bugzilla 1385: Stack Overflow with huge array literal.
Bugzilla 1428: Segfault on template specialization with delegates and tuples
Bugzilla 1791: Segmentation fault with anon class in anon class and non-constant variable init
Bugzilla 1916: segfault on invalid string concat
Bugzilla 1946: Compiler crashes on attempt to implicit cast const typedef to non-const.
Bugzilla 2048: DMD crash on CTFE that involves assigning to member variables of void-initialized struct
Bugzilla 2061: wrong vtable call with multiple interface inheritance
Bugzilla 2215: Forward reference enum with base type within a struct causes Segmentation Fault in the compiler
Bugzilla 2309: Crash on a template mixing in a variadic template with an undefined template identifier
Bugzilla 2346: ICE when comparing typedef'd class
Bugzilla 2580: Documented WinMain for D2 is wrong
Bugzilla 2633: incorrect ModuleInfo declaration in object.di
Bugzilla 2695: pure functions can invoke impure function pointers
Bugzilla 2807: Marking a nested function as 'pure' may cause bad code generations silently accepted
Bugzilla 2821: struct alignment inconsistent with C for { int, long }
Bugzilla 2851: Segfault using C-style struct initializer with too few arguments
Bugzilla 2865: RandomCover not random
Bugzilla 2882: std.random.MersenneTwisterEngine without seed
Bugzilla 2890: deadlock in std.stdio
Bugzilla 2893: qualified types don't have an Unsigned counterpart
Bugzilla 2906: writef problem with formatting floating point
Bugzilla 2914: to!string(struct) is broken
Bugzilla 2920: recursive templates blow compiler stack
Bugzilla 2922: Egregiously bad hashing performance with strings

Version D 2.029 Apr 19, 2009

New/Changed Phobos

std.algorithm
- Everything converted to ranges. Big disruption. Algorithms added.
std.array
- Range primitives for arrays
- Appender template
- insert, replace functions
std.bitmanip
- Bitfields of length 0 are defined to be always 0.
- The read functions for bitfields are const.
std.contracts
- enforce accepts const(char)[] instead of string
- Added enforce overload that invokes a delegate on failure
- Added assumeSorted template
- Added structuralCast that implements, well, structural casting (incomplete).
std.conv
- Rewrote conversions with constrained templates.
- Added text() function that transforms everything into text.
std.date
- Added a benchmark function that allows for simple timing measurements.
std.file
- read, write, append, rename, remove, getSize, getTimes, getAttributes, isfile, isdir, chdir, mkdir, mkdirRecurse, rmdir, listdir, copy, take filename(s) by "in char[]"
- Added function readText that reads and validates a text file
- 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.
std.format
- 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.
- Added a formattedRead function (i.e., scanf that doesn't suck). The implementation is incomplete but common cases are supported.
std.functional
- Improved error messages
- Added configurable parameter names for functions as strings
- Added Adjoin template
std.getopt
- Added support for parameterless delegates
std.math
- Intrinsics std.math.yl2x and yl2xp1 added. Improves performance of std.math.log() and similar functions (and they are now pure nothrow).
std.mmfile
- Minor cosmetic changes
std.numeric
- Added type CustomFloat that allows defining specialized floating-point numbers (e.g. 16-bit floats, positive floats etc.)
- Added FPTemporary as the best type to store temporary values.
- Templatized oppositeSigns
- Added Euclidean distance
- Added dotProduct
- Added cosineSimilarity
- Added normalize
- Added string kernel functions gapWeightedSimilarity, gapWeightedSimilarityNormalized, gapWeightedSimilarityIncremental.
std.outbuffer
- Added a few missing overloads of write()
std.path
- getDrive now works with all string types
- isabs accepts in char[]
- join accepts variadic in char[]
- fnmatch works with in char[]
std.random
- Added RandomCover that covers a given range in a random manner
- Eliminated the old-fashioned random functions
- Defined a default random object that simplifies calls to the random functions
- Changed generators to obey the range interface. So now you can write:
```
Random r;
foreach (n; take(100, uniform(0, 100))) { ... }
```
std.range (new file)
- Range manipulation stuff.
std.regex (new file)
- Regular expression library with wide char support, simplified interface, better speed etc.
std.regexp
- Scheduled for deprecation. Use std.regex instead.
std.stdio
- Major breaking changes: introduced the File struct. Now stdin, stdout, stderr are instances of the File struct.
- 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.
- A byRecord iteration mode makes it pretty easy to iterate structured text files.
- writef and writefln now require a string as their first argument.
std.string
- strip, stripl, stripr, startsWith, endsWith now work with any string type
std.typecons
- Added constructors, assignment operator, length, toString, and slice to Tuple.
std.utf
- toUTF16z accepts in char[]
std.variant
- Added support for Variants that contain vectors and hashes of themselves
std.c.stdio
- Added fopen64 and friends

New/Changed Features

Added template function literals

Bugs Fixed

Bugzilla 675: %a format has an out-by-1 bug for denormals
Bugzilla 2199: Segfault using array operation in function call
Bugzilla 2203: typeof(class.template.foo) crashes compiler
Bugzilla 2577: DMD crashes on foreach of undefined identifier
Bugzilla 2808: 'nothrow' nested functions cannot be parsed
Bugzilla 2812: sqrt(2.0) is about -2.7341e-53

Version D 2.028 Apr 7, 2009

New/Changed Features

Bugs Fixed

Bugzilla 1586: DMD and GDC segfaults on incomplete code segment
Bugzilla 2064: Segfault with mixin(for/foreach) with empty loop body
Bugzilla 2812: sqrt(2.0) is about -2.7341e-53
Bugzilla 2804: Impure nested functions should be legal inside pure functions

Version D 2.027 Mar 31, 2009

New/Changed Features

Most functions in std.math are now pure nothrow. Improved speed of std.math.hypot.
Added response files for Linux and OSX
Added alias this
Bugzilla 2746: Make float.init signalling NaN by default
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.
Folded in patches for LDC compatibility from Tomas Lindquist Olsen
Removed etc.gamma from the library.

Bugs Fixed

std.math.hypot is wrong for subnormal arguments
Fix bug where / wasn't recognized as a path separator on Windows.
Bugzilla 920: Fix one more out of date reference to 'auto' rather than 'scope'
Bugzilla 1645: can override base class' const method with non-const method
Bugzilla 2319: "Win32 Exception" not very useful
Bugzilla 2336: link to nonexistent std_array.html
Bugzilla 2570: Patch for some mistakes in Ddoc comments
Bugzilla 2574: std.c.stdio doesn't compile: va_list not defined!
Bugzilla 2591: custom allocator new argument should be size_t instead of uint
Bugzilla 2595: template ctors crash compiler
Bugzilla 2596: Variadic constructors don't compile
Bugzilla 2626: template function not working against template struct instantiated with default arguments
Bugzilla 2674: Copy postblit constructor this(this) not called for members
Bugzilla 2689: seek behaves incorrectly on MAC OSX
Bugzilla 2692: alignment of double on x86 linux is incorrect
Bugzilla 2700: typeof tests stops compilation abruptly
Bugzilla 2705: Response file size cannot exceed 64kb
Bugzilla 2711: -H produces bad headers files if function defintion is templated and have auto return value
Bugzilla 2722: ICE with variadic template parameters
Bugzilla 2723: ICE with variadic template parameters, different case
Bugzilla 2724: Persistent segfaults in templated code
Bugzilla 2725: Pattern matching in static if not working with variadic arguments
Bugzilla 2727: std.date Cyclic dependency
Bugzilla 2728: Bogus Error message on const ref return
Bugzilla 2729: hash_t undocumented and unnecessary
Bugzilla 2730: Restriction on op= can be lifted
Bugzilla 2731: Errors in associative array example
Bugzilla 2739: _argptr is invalid for functions nested in class methods
Bugzilla 2743: dumpobj gives "buss error" on Tiger
Bugzilla 2744: wrong init tocbuffer of forstatement
Bugzilla 2745: missing token tochars in lexer.c
Bugzilla 2747: improper toCBuffer of funcexp
Bugzilla 2750: Optimize slice copy with size known at compile time
Bugzilla 2751: incorrect scope storage class vardeclaration tocbuffer
Bugzilla 2752: std.xml does not encode CData correctly
Bugzilla 2754: The error message regarding implicit conversion to shared doesn't mention shared in the message.
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.
Bugzilla 2756: Bad code generation for pure nothrow math functions
Bugzilla 2761: Unreachable statement warning in std.string
Bugzilla 2763: std.mangle.demangle not translating 'ya'
Bugzilla 2766: DMD hangs with 0%cpu
Bugzilla 2767: DMD incorrectly mangles NTFS stream names
Bugzilla 2772: lib can't open response file

Version D 2.026 Mar 3, 2009

New/Changed Features

Escape string literals deprecated, see Bugzilla 2658
Tripled speed of exp, expm1, and exp2. std.math is now less dependent on the C standard library.
Added nested structs.
Added buildable dmd source.
Many changes to std.math for speed, accuracy, and Tango compatibility:
- Improved accuracy of exp, expm1, exp2, sinh, cosh, tanh on Mac OSX, and tripled speed on all platforms.
- Now using IEEE754-2008 camelCase names for isNaN, isFinite, isNormal, isSubnormal, isInfinity. Aliases for the old names have been retained.
- The non-functional nan(char[]) is replaced with NaN, getNaNpayload.

Bugs Fixed

Bugzilla 1603: String literals bind to pointer types
Bugzilla 1629: Link error: Previous Definition Different: blablah__initZ
Bugzilla 1662: Falls back to libphobos if -debuglib isn't used when -g is
Bugzilla 1681: cast(real) ulong.max == 0
Bugzilla 2416: Slice of typedef'ed array should preserve the typedef'ed type
Bugzilla 2597: auto return doesn't work for a variety of cases
Bugzilla 2612: immutable not accepted wherever invariant is
Bugzilla 2619: Locally-instantiated structs are not instantiated locally
Bugzilla 2621: ref binds to rvalues of user-defined types
Bugzilla 2622: ref returns not allowed in complex template
Bugzilla 2623: Function type drops ref spec
Bugzilla 2670: std.file.read() should read files of 0 length
Bugzilla 2673: Static constructors sometimes do not run when compiling with -lib
Bugzilla 2675: cannot foreach structs with copy constructor
Bugzilla 2676: alias parameters not matched in concept if clause
Bugzilla 2677: Alias type parameters not visible in concept-if clauses
Bugzilla 2678: for loops are already assumed to terminate
Bugzilla 2679: Spurious "warning - " messages and erratic behaviour with is(typeof({void function}()))
Bugzilla 2684: Associative arrays have wrong opIndex signatures
Bugzilla 2690: DMD aborts with MALLOC_CHECK_ set

Version D 2.025 Feb 14, 2009

New/Changed Features

Added Mac OSX support.
Separated bin and lib directories into windows, linux, and osx.
No longer need to download dmc to use the windows version.
Use version(OSX) for Mac OSX. Although version(darwin) is also supported for the time being, it is deprecated.

Bugs Fixed

Bugzilla 2448: template return by reference causes seg fault

Version D 2.023 Jan 2, 2009

New/Changed Features

Improved speed of long division.
Optimizer now takes advantage of immutable and pure.
Added predefined version D_Ddoc which is predefined when -D switch is thrown.
the type of a string literal is now invariant(char)[] rather than invariant(char)[length_of_string]. It is still implicitly convertible to the latter. This is intended to reduce template instantiation bloat.
Undid fix for Bugzilla 2500, as the fix was arguably worse than the bug.

Bugs Fixed

Bugzilla 1078: Frontend uses of 'auto' where 'scope' should be used
Bugzilla 2517: DDoc omits abstract on classes
Bugzilla 2518: scope(success) not execuate and RAII variable destructor is not called
Bugzilla 2519: Segfault when >> used in an invalid slice
Bugzilla 2527: Alias Template Params Are Always Same Type As First Instantiation (according to typeof(x).stringof)
Bugzilla 2531: DDoc not generated correctly for struct methods inside static if
Bugzilla 2533: compiler falls with "assertion failed" message on wrong code
Bugzilla 2534: dmd.conf is wrong
Bugzilla 2537: compiler crashes on this code:
Bugzilla 2541: cannot use aliased type for decl of foreach variable
Bugzilla 2542: array casts behave differently at compile and runtime

Version D 2.022 Dec 11, 2008

New/Changed Features

Changed IUnknown to use the extern(System) interface rather that extern(Windows).
Pure functions now get semantically checked.
Nothrow functions now get semantically checked.
shared is now a type constructor.

Bugs Fixed

Bugzilla 1518: Crash using 'scope', 'with' and undefined 'RegExp'
Bugzilla 1649: Variant coercion fails with delegates
Bugzilla 1685: Array index is evaluated twice
Bugzilla 1933: Delimited string constants can cause segfault
Bugzilla 1963: -H creates broken headers
Bugzilla 2041: Spec implies relationship between interfaces and COM objects
Bugzilla 2105: added patch
Bugzilla 2441: header file generation translates enum to manifest
Bugzilla 2468: result type of AndAndExp and OrOrExp deduced incorrectly
Bugzilla 2489: import in struct causes assertion failure
Bugzilla 2490: extern(C++) can not handle structs as return types
Bugzilla 2491: druntime GC wrongly frees data pointed to by TLS.
Bugzilla 2492: ICE building on Linux with -lib option
Bugzilla 2499: Template alias default value cannot be template instantiation
Bugzilla 2500: template struct methods are left unresolved if imported from multiple modules
Bugzilla 2501: member function marked as final override ignores override requirements
Bugzilla 2503: Error 42: Symbol Undefined _D3std7process6systemFAyaZi
Bugzilla 2506: Can't initialize const member in ctor if it is accessed via this.member syntax
Incorporated some of the patches from Bugzilla 1752
extern __thread now works on Linux.

Version D 2.021 Nov 25, 2008

New/Changed Features

Added -safe switch and module(system) Identifier; syntax.
Added range support to foreach statement.
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.
The lazy storage class now implies scope so that lazy arguments won't trigger a heap allocated closure.
The 'this' parameter to struct member functions is now a reference type, rather than a pointer. This breaks existing code.

More changes to druntime:

from	to
OutOfMemoryException	OutOfMemoryError
SwitchException	SwitchError
HiddenFuncException	HiddenFuncError
ArrayBoundsException	RangeError
AssertException	AssertError
FinalizeException	FinalizeError
onArrayBoundsError	onRangeError
stdc.*	core.stdc.*
sys.*	core.sys.*

Added core.runtime.loadLibrary() as an experimental feature for loading dynamic libraries (Win32 only at the moment).
Added core.runtime.unloadLibrary() as an experimental feature for unloading dynamic libraries previously loaded by loadLibrary().
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).
It is no longer necessary to link in druntime separately, it is inserted into libphobos2.a.

Bugs Fixed

Bugzilla 313: Fully qualified names bypass private imports
Bugzilla 920: SPEC: Auto classes referenced where scope should be used
Bugzilla 929: Resizing array of associative arrays (uint[char[]][]) causes infinite loop / hang
Bugzilla 1372: Compiler accepts pragma(msg,)
Bugzilla 1610: Enum.stringof is int, not the name of the enum
Bugzilla 1663: pragma(lib, "") don't work on linux
Bugzilla 1797: Documentation comments - ///
Bugzilla 2428: Accessing item in enum'd array produced compiler error
Bugzilla 2429: std.stream.File incorrect flag parsing and sharing mode
Bugzilla 2431: Internal error: ../ztc/cgcod.c 1031 when using -O
Bugzilla 2470: Cannot build libraries from other libraries
unittest functions now always use D linkage

Version D 2.020 Oct 20, 2008

New/Changed Features

Improved performance of AAs by rebalancing trees when rehashing.
immutable now is implemented.
Bugzilla 2344: Two wrong lookups for array functions
Bugzilla 2345: Return by reference should be allowed
Posix is now a predefined identifier when compiling under Linux

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:

from	to
bit	bool
_d_OutOfMemory()	onOutOfMemoryError()
import std.asserterror;	import core.exception;
import std.hiddenfunc;	import core.exception;
import std.switcherr;	import core.exception;
import std.array;	import core.exception;
import std.outofmemory;	import core.exception;
import std.gc;	import core.memory;
import std.thread;	import core.thread;
SwitchError	SwitchException
AssertError	AssertException
HiddenFuncError	HiddenFuncException
ArrayBoundsError	ArrayBoundsException
std.gc.fullCollect()	GC.collect()
std.gc.*()	memory.gc_*()
_moduleUnitTests()	import runtime; runModuleUnitTests()
printf	add import std.c.stdio;

Changes to thread:

The thread handle isn't exposed to the user. This can always be obtained using the appropriate OS calls from within the thread.
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.
Thread.wait() is renamed to Thread.join().
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.

Bugs Fixed

Bugzilla 1229: Linker fills disk
Bugzilla 2332: Initializing const or invariant hashes croaks
Bugzilla 2333: Hash initializer does not work
Bugzilla 2336: link to nonexistent std_array.html
Bugzilla 2340: Template properties don't work
Bugzilla 2341: Double destruction without intervening copy
Bugzilla 2362: Confusing description of 'aliasing of invariant with mutable'?
Bugzilla 2363: Spurious () required after function name when used with array in prefix form
Bugzilla 2366: Const member function syntax is missing
Bugzilla 2368: Calling a function with an address of another function, then calling a returned object is rejected
Bugzilla 2373: freebsd select does not accept values > 999,999
Bugzilla 2376: CTFE fails on array literal of array literals of chars
Bugzilla 2380: static struct initializer accepted as non static initializer is not documented
Bugzilla 2383: default arguments can implicitly access private global variables that are not visible at call site
Bugzilla 2385: spec says all structs are returned via hidden pointer on linux, but it uses registers
Bugzilla 2390: Missing warning on conversion from int to char

Version D 2.019 Sep 2, 2008

New/Changed Features

Added struct constructors.
Special member functions _ctor, _dtor, etc., now have two leading _ in order to not conflict with the user identifier space.

Bugs Fixed

Bugzilla 1322: foreach bypasses invariant
Bugzilla 1615: inout is allowed in foreach of string literal
Bugzilla 1627: ICE with a method called _ctor
Bugzilla 1633: Nonsensical "C style cast illegal" message with !is
Bugzilla 1771: dmd fails to execute on linux
Bugzilla 1773: excessively long integer literal
Bugzilla 1785: Mixing in an incorrect array literal causes infinite loop.
Bugzilla 2176: Assertion failure: 'sz == es2->sz' on line 1339 in file 'constfold.c' (concatenating strings of different types)
Bugzilla 2183: Bad formatting in std.c.stdlib
Bugzilla 2190: toHash documentation is deprecated [D2.0]
Bugzilla 2232: DMD generates invalid code when an object file is compiled -inline
Bugzilla 2241: DMD abort
Bugzilla 2243: const bool = is(function literal), badly miscast
Bugzilla 2262: -inline breaks -lib library
Bugzilla 2286: movmskpd compiled incorrectly
Bugzilla 2287: std.conv should accept structs defining toString
Bugzilla 2289: Stack overflow on very large BigInt to string.
Bugzilla 2308: CTFE crash on foreach over nonexistent variable
Bugzilla 2311: Static destructors in templates are never run
Bugzilla 2314: Crash on anonymous class variable instantiation
Bugzilla 2316: std.file docs are out of date
Bugzilla 2317: asm offsetof generates: Internal error: ../ztc/cod3.c 2651

Version D 2.018 Aug 7, 2008

New/Changed Features

Now supports array operations.

Bugs Fixed

Added hash to generated module names when building libs to reduce collisions
Bugzilla 1622: parameters to TypeInfo_Struct.compare seem to be switched around.
Bugzilla 1644: Template instantiation should automatically cast to const to make const-ness irrelevant when argument is const anyways
Bugzilla 2216: bad code generation for static arrays of zero length static arrays
Bugzilla 2223: Typo in error message
Bugzilla 2231: missing bigint document
Bugzilla 2242: linux system calls are canceled by GC
Bugzilla 2247: bad header file generated for if (auto o = ...) {}
Bugzilla 2248: .di should be a supported file extension
Bugzilla 2250: Update of user32.lib and kernel32.lib
Bugzilla 2254: Size of executable almost triples
Bugzilla 2258: Docs -> Inline Assembler -> Operand Types -> qword missing
Bugzilla 2259: Assertion failure: '0' on line 122 in file 'statement.c'
Bugzilla 2266: opEquals documentation still says it returns int
Bugzilla 2269: D BUG: cosine of complex
Bugzilla 2272: synchronized attribute documentation
Bugzilla 2273: Whitespace is not inserted after commas

Version D 2.017 Jul 11, 2008

New/Changed Features

Bugs Fixed

Bugzilla 2207: overload resolution fails with deprecation
Bugzilla 2208: Deprecated function declarations cannot use deprecated types
Bugzilla 2209: Typo in doc for offsetof
Bugzilla 2212: phobos itself should be able to be compiled with '-w' switch
Bugzilla 2264: typo in documentation regarding atof.

Version D 2.016 Jul 8, 2008

New/Changed Features

re-implemented internal.monitor in D. Rationalized internal.object
Bugzilla 288: changed return type of opEquals from int to bool. This necessitates doing a grep for opEquals and changing all the return values.
Added .__vptr and .__monitor properties for class objects for use in the internal runtime library.
Made rdmd's source available through svn, see http://dsource.org/projects/phobos/browser/trunk/tools/rdmd.d
Simplified std.algorithm by fusing together higher-order functions taking an alias and their counterparts taking a string
Added module std.array containing array operations: insert, erase, and replace
Changed the enforce's implementation to generate smaller code per call
Changed std.functional.binaryFun to work with strings and function aliases alike
In std.getopt, added optChar, assignChar, and endOfOptions, per popular demand :o|
In std.math, replaced a bunch of consts with enums
In std.numeric, added Don Clugston as author and operated minor documentation fixes
Improved std.stdio.chunks to take an iteration tally in addition to the chunk

Bugs Fixed

D.announce/12322: mixin regression
Bugzilla 203: std.format.doFormat() pads width incorrectly on Unicode strings
Bugzilla 211: Linking error with alias mixin params and anonymous methods
Bugzilla 224: Incorrect warning "no return at end of function"
Bugzilla 252: -w and switch returns = bogus "no return at end of function" warning
Bugzilla 253: Invalid <dl> tag generated by Ddoc
Bugzilla 294: DDoc: Function templates get double and incomplete documentation
Bugzilla 398: No way to abort compilation in a doubly recursive mixin
Bugzilla 423: dmd ignores empty commandline arguments
Bugzilla 515: Spec incorrect in where .offsetof can be applied
Bugzilla 520: Invariants allowed to call public functions
Bugzilla 542: Function parameter of a deprecated type (other than a class) is not caught
Bugzilla 543: Function return of a deprecated type is not caught
Bugzilla 544: Variable declared of a deprecated type (other than a class) is not caught
Bugzilla 545: Attempt to access a static built-in property of a deprecated struct, union, enum or typedef is not caught
Bugzilla 547: Accessing a deprecated member variable through an explicit object reference is not caught
Bugzilla 548: Accessing a value of a deprecated enum is not caught
Bugzilla 566: Adding non-static members and functions to classes using a template doesn't error
Bugzilla 570: Bogus recursive mixin error
Bugzilla 571: class instance member template returns strange value
Bugzilla 572: parse error when using template instantiation with typeof
Bugzilla 581: Error message w/o line number in dot-instantiated template
Bugzilla 617: IFTI doesn't use normal promotion rules for non-template parameters
Bugzilla 870: contradictory error messages for templates
Bugzilla 951: Missing line number: no constructor provided for a class derived from a class with no default constructor
Bugzilla 1097: Missing line number: casting array to array of different element size
Bugzilla 1158: Missing line number: invalid mixin outside function scope
Bugzilla 1176: Error missing file and line number
Bugzilla 1187: Segfault with syntax error in two-level mixin.
Bugzilla 1194: fcmov* emmits incorrect code
Bugzilla 1207: Documentation on destructors is confusing
Bugzilla 1341: typeof(int) should probably be legal
Bugzilla 1601: shr and shl error message is missing line numbers
Bugzilla 1612: No file/line number for using an undefined label in inline assembly
Bugzilla 1912: Error without line number (Tuple, invalid value argument)
Bugzilla 1936: Error with no line number (array dimension overflow)
Bugzilla 2076: asm: offset has wrong docs and error without line number
Bugzilla 2161: Modify compiler to pass array TypeInfo to _adEq and _adCmp instead of element TypeInfo
Bugzilla 2178: 3 errors without line number: typeof
Bugzilla 2188: man-or-boy test fails with access violation
Fixed bugs in std.file.rename and std.file.remove on Linux
Fixed documentation in std.typecons

Version D 2.015 Jun 17, 2008

New/Changed Features

Template alias arguments can now be literals.
Function templates can now deduce the return type if they are declared with auto.
Non-lvalues are no longer matched to ref and out parameters when overloading.
Relaxed hidden hijacking detection when hidden function is disjoint from overloading with any other virtual function in the hierarchy.
Added version identifier D_PIC when -fPIC switch is used.
Added Constraints to templates.

Bugs Fixed

Bugzilla 1383: Implicit Function Instantiation with typesafe-variadic of delegates doesn't work
Bugzilla 1559: version statement makes code outside of it disappear
Bugzilla 1675: "Identifier too long" error with OMF object files
Bugzilla 1947: ICE (Assertion failure: '0' on statement.c:123) with null mixin
Bugzilla 1963: -H creates broken headers
Bugzilla 2098: Outdated docs
Bugzilla 2099: Text and Sample Code Disagree (non-static local invariant declaration)
Bugzilla 2112: the type of undefined variable incorrectly assumed to be int
Bugzilla 2118: Inconsistent use of string vs invariant(char[]) in doc
Bugzilla 2123: Anonymous class crashes
Bugzilla 2129: foreach won't work with invariant limits
Bugzilla 2132: CTFE: can't evaluate ~= at compile time, D2 only.
Bugzilla 2133: anonymous enum without {} doesn't work as asm value
Bugzilla 2136: typeof(super(...)) counted as a constructor call
Bugzilla 2140: static if as final statement with no code causes containing code to be skipped
Bugzilla 2143: Mixed-in identifier is not recognized by static if
Bugzilla 2144: 'is' is defined to be the same as '==' for non-class and non-array types, but does not call opEquals
Bugzilla 2145: Phobos buildsystem unable to build html
Bugzilla 2146: Multiple execution of 'static this' defined in template
Bugzilla 2149: Auto variables loose the keyword "auto" in di files generated with -H option.

Version D 2.014 May 16, 2008

New/Changed Features

Added -man switch to browse manual.
Added -lib switch to generate library files. Also causes multiple object files to be generated from one source module.
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.
Rewrote the rdmd utility to properly track dependencies and command-line compiler options (currently only working under Linux).
Changed the Phobos makefile linux.mak to take advantage of the new -lib feature. Improved full build speed by 3x.
std.algorithm: Changed the map() function so that it deduces the return type. Also map can be now curried.
std.contracts: Added file and line information to enforce. Added errnoEnforce that formats the error message according to errno. Added corresponding ErrnoException class.
std.conv: Made std.to curryable. Changed std.to to throw exception when object-to-object cast fails. Eliminated some superfluous printfs.
std.encoding: Added new functions encodedLength(dchar) and encode(dchar, ref E[])
std.encoding: Got rid of types Utf8, Utf16, Utf32, Ascii, Latin1, Windows1252. Introduced types AsciiChar, AsciiString, Latin1Char, Latin1String, Windows1252Char, Windows1252String.
std.encoding: For now commented out std.encoding.to.
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.
std.functional: Improved compose so it accepts an unbounded number of functions. Added the pipe function.
std.getopt: Added new option stopOnFirstNonOption. Also automatically expand dubious option groups with embedded spaces in them (useful for shebang scripts)
std.math: improved integral powers
std.md5: Improved signature of sum so it takes multiple arrays. Added getDigestString.
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.
std.process: added getenv and setenv. Improved system() so it returns the exit code correctly on Linux.
std.random: added the dice function - a handy (possibly biased) dice.
std.typecons: Finalized and documented the stupendous Rebindable template.
std.utf: added the codeLength function. Got rid of some gotos.

Bugs Fixed

std.format: Fixed unlisted bug in raw write for arrays
std.getopt: Fixed unlisted bug in dealing with one-letter options with bundling disabled
Bugzilla 2014: fopen fails on large files.
Bugzilla 2031: Documentation: template value parameters
Bugzilla 2032: Documentation for creating a class on the stack is unintuitive
Bugzilla 2037: Article on hijacking is outdated
Bugzilla 2038: Remove hello2.html from samples directory
Bugzilla 2039: -ignore switch is missing from compiler docs
Bugzilla 2054: Const system broken on struct assignment.
Bugzilla 2055: (ICE) Compiler crash on struct initializer with too many elements
Bugzilla 2056: Const system does not allow certain safe casts/conversions involving deep composite types
Bugzilla 2058: Describe hidden value passed to class member functions
Bugzilla 2063: std.xml access violation for nested, closed tags
Bugzilla 2065: Return value of std.file.exists() is inverted.
Bugzilla 2067: call from anonymous class makes access violation.
Bugzilla 2071: spec doesn't mention pointer arithmetic with two pointer operands
Bugzilla 2072: std.typecons documentation anomaly.
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.
Bugzilla 2075: Spec does not specify how array literals are stored.
Bugzilla 2084: operator ?: does not compute the tightest type
Bugzilla 2086: Describe relationship between string and char[] more explicitly
Bugzilla 2089: Issues with CTFE and tuple indexes
Bugzilla 2090: Cannot alias a tuple member which is a template instance
Bugzilla 2100: Assertion failure: '0' on line 4842 in file 'expression.c'
Bugzilla 2109: asm {lea EAX, [0*0+EAX]; } rejected.

Version D 2.013 Apr 22, 2008

New/Changed Features

Added -ignore switch to ignore unsupported pragmas.
Unsupported pragmas now printed out with -v switch.
Added opDot, which is experimental only.
SwitchStatements can now accept runtime initialized const and invariant case statements.
Changed __FILE__ and __LINE__ so they work as parameter default initializers.
Incorporated Benjamin Shropshire's doc changes
Hidden methods now get a compile time warning rather than a runtime one.
Html source files are now deprecated.
Added pure and nothrow function attributes, although their semantics are not implemented.
Deprecated VolatileStatement; use SynchronizedStatement instead.
Added __thread storage class for thread local storage. This is for testing purposes only to check out the machinery in the back end. The front end design of this will change.
obj2asm and dumpobj now better handle special ELF fixup records.
Added partial ordering rules to disambiguate function overloading.
std.perf: Bill Baxter cleaned it up.
std.xml.Document constructor now creates whole DOM tree.
Added std.encoding.

Bugs Fixed

D/69085: const/invariant bug?
Bugzilla 1712: vtbl[0] for interface not set to corresponding Interface*
Bugzilla 1723: __traits(getVirtualFunctions) on a non-function fails badly
Bugzilla 1741: crash on associative array with static array as index type
Bugzilla 1905: foreach docs inconsistency
Bugzilla 1906: foreach cannot use index with large arrays
Bugzilla 1925
Bugzilla 1935: The std.recls samples in the DMD .zip are obsolete.
Bugzilla 1967: getDirName does not seem to use altsep on windows
Bugzilla 1978: Wrong vtable call
Bugzilla 1991: Dmd hangs
Bugzilla 2016: 'invariant' TypeSpecialization is missing
Bugzilla 2019: Appending a one-element array literal doesn't work

Version D 2.012 Mar 6, 2008

New/Changed Features

Added predefined version(unittest). See Bugzilla 458
Removed std.math2
Added compile time error for comparing class types against null.
Added struct destructors and postblits.
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).
std.bitmanip: simplified code generated for bitfields and improved error message.
std.format: ate dogfood: used bitfields internally.
std.functional: fixed binaryfun to work with constant-size arrays; added compose.
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 '[', '(' to one string "[(" throughout.
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.
std.typecons: added undocumented Rebindable in preparation for opImplicitCast.
std.math:
- 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.
- Added implementation of nextafter Bugzilla 1722 and scalb for DMD-Windows.
- Added nextUp(), nextDown()
- Bugzilla 1881: feqrel nonsensical for non-real arguments.
- internal functions isPosZero(), isNegZero() removed in favour of the more generally useful isIdentical().
- asm versions of functions which were not implemented by DMD Windows: scalb, lrint.
- added creal expi(real y) which is useful for simultaneous calculation of sin + cos.

Bugs Fixed

std.contracts: fixed unlisted bug in pointsTo.
std.conv: fixed bug related to number-to-number conversion (T.min hits again).
Fixed dwarf bug with DT_AT_upper_bound
Bugzilla 756: IFTI for tuples only works if tuple parameter is last
Bugzilla 1454: IFTI cant deduce parameter if alias argument used
Bugzilla 1661: Not possible to specialize on template with integer parameter
Bugzilla 1800: Compiler crash on enums nested in structs
Bugzilla 1801: Const structs should be assignable to non-const variables unless they contain references
Bugzilla 1806: "const" makes typesafe variadic arguments not work properly.
Bugzilla 1809: template.c:2600
Bugzilla 1810: MmFile anonymous mapping does not work under win32
Bugzilla 1819: spurious warning about missing return statement after synchronized
Bugzilla 1821: ICE when using __traits isSame on const/invariant variables
Bugzilla 1823: Implicit conversion to const on associative array
Bugzilla 1828: Several Thread Issues
Bugzilla 1833: std.c.windows.windows should use enums for constants, or be more selective about use of extern(Windows)
Bugzilla 1836: Inline assembler can't use enum values as parameters.
Bugzilla 1837: Make dmd stop flooding the console: prints content of passed parameter file
Bugzilla 1843: Bogus unreachable statement on forward referenced struct, lacks line number
Bugzilla 1850: The compiler accepts lower case asm registers.
Bugzilla 1851: missing opCall? when cast away const struct
Bugzilla 1852: you get opCall missing when cast to a struct(diagnostic)
Bugzilla 1853: opCmp documentation really needs some examples
Bugzilla 1854: bug in new flow analysis (warnings on valid code)
Bugzilla 1857: Runtime segfault while profileing - jump to invalid code address
Bugzilla 1862: asm: [ESI+1*EAX] should be a legal addr mode
Bugzilla 1865: Escape sequences are flawed.
Bugzilla 1867: lazy adds spurious const qualifier
Bugzilla 1871: DMD debug messages printed
Bugzilla 1873: structs with at least one immutable member are completely immutable
Bugzilla 1874: __traits(allMembers, T) fails to list methods which only have non-mutating overloads
Bugzilla 1876: inside a non-static class method, should "&( f)" be same as "&(this.f)" ?
Bugzilla 1877: Errors in the documentation of std.math.atan2
Bugzilla 1882: Internal error: ..\ztc\cod1.c 2529
Bugzilla 1883: templates instantiated as real gives incorrect values
Bugzilla 1884: manifest constants for strings
Bugzilla 1885: Syntax error for object identity test between invariant/mutable references
Bugzilla 1887: compiler freeze on array of dyn. arrays with empty first initializer

Version D 2.011 Feb 18, 2008

New/Changed Features

std.typecons: fixed code bloat issue; added Tuple.toString; added function tuple(); fixed unlisted bug in enumValuesImpl.
std.process: added function shell().
std.math: minor change in approxEqual.
std.contracts: added functions pointsTo()
std.numeric: minor unittest fixes.
std.bitmanip: fixed code bloat issue, reintroduced FloatRep and DoubleRep.
std.conv: minor simplification of implementation.
std.regexp: added reference to ECMA standard in the documentation.
std.getopt: changed return type from bool to void, error is signaled by use of exceptions.
std.functional: added unaryFun, binaryFun, adjoin.
std.string: updated documentation, changed code to compile with warnings enabled.
std.traits: changed FieldTypeTuple; added RepresentationTypeTuple, hasAliasing; fixed bug 1826; added call to flush() from within write; fixed unlisted bug in lines().
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.
std.thread: fixed so it compiles with warnings enabled.
std.file: made getSize() faster under Linux.
std.random: fixed so it compiles with warnings enabled; improved function uniform so it deduces type generated from its arguments.
std.format: added fixes to make formatting work with const data.
std.path: minor documentation changes.
Added std.xml
Added std.complex
Added std.iterator
Added std.c.linux.tipc
Added std.c.linux.termios
Added nothrow keyword
Re-enabled auto interfaces.
Now allow static arrays to be lvalues.
Now allows implicit casting of null to/from const/invariant.
Now allows implicit casting of StructLiterals if each of its arguments can be implicitly cast.
Now allows implicit casting of structs to/from const/invariant if each of its fields can be.
Added pragma startaddress.
.tupleof can now access private fields of a struct/class
Enhancement Bugzilla 493: Partial IFTI does not work

Bugs Fixed

Fixed D/66406 Remaining const niggles #1 - Custom POD types
Fixed display of ddoc template parameters that were aliased
Fixed bug in std.file.readln() for Windows in translated mode
Bugzilla 1072: CTFE: crash on for loop with blank increment
Bugzilla 1435: DDoc: Don't apply DDOC_PSYMBOL everywhere
Bugzilla 1815: foreach with interval does not increment pointers correctly
Bugzilla 1825: local instantiation and function nesting
Bugzilla 1837: Make dmd stop flooding the console: prints content of passed parameter file
Bugzilla 1842: Useless linker command line output during compilation on Linux

Version D 2.010 Jan 20, 2008

New/Changed Features

opAssign can no longer be overloaded for class objects.
WinMain and DllMain can now be in template mixins.
Added pure keyword.

Bugs Fixed

Bugzilla 1319: compiler crashes with functions that take const ref arguments
Bugzilla 1697: Internal error: ..\ztc\cgcod.c 2322 with -O
Bugzilla 1700: ICE attempting to modify member of const return struct
Bugzilla 1707: '==' in TemplateParameterList in IsExpression causes segfault
Bugzilla 1711: typeof with delegate literal not allowed as template parameter
Bugzilla 1713: foreach index with tuples and templates fails
Bugzilla 1718: obscure exit with error code 5
Bugzilla 1719: Compiler crash or unstable code generation with scoped interface instances
Bugzilla 1720: std.math.NotImplemented missing a space in message
Bugzilla 1724: Internal error: toir.c 177
Bugzilla 1725: std.stream.BufferedFile.create should use FileMode.OutNew
Bugzilla 1757: there is an fault in phobos windows api interface
Bugzilla 1762: Wrong name mangling for pointer args of free extern (C++) functions
Bugzilla 1767: rejects-valid, diagnostic
Bugzilla 1769: Typo on the page about exceptions
Bugzilla 1773: excessively long integer literal
Bugzilla 1779: Compiler crash when deducing more than 2 type args
Bugzilla 1783: DMD 1.025 asserts on code with struct, template, and alias
Bugzilla 1788: dmd segfaults without info
D.announce/11066: Re: DMD 1.025 and 2.009 releases

Version D 2.009 Jan 1, 2008

New/Changed Features

Redid const/invariant semantics again.
Extended enums to allow declaration of manifest constants.

Bugs Fixed

Bugzilla 1111: enum value referred to by another value of same enum is considered as enum's base type, not enum type
Bugzilla 1694: Zip::ArchiveMember::name format bug
Bugzilla 1702: ICE when identifier is undefined
Bugzilla 1738: Error on struct without line number
Bugzilla 1742: CTFE fails on some template functions
Bugzilla 1743: interpret.c:1421 assertion failure on CTFE code
Bugzilla 1744: CTFE: crash on assigning void-returning function to variable
Bugzilla 1745: Internal error: ..\ztc\out.c 115
Bugzilla 1749: std.socket not thread-safe due to strerror
Bugzilla 1753: String corruption in recursive CTFE functions
D/63456: Cannot overload on constancy of this

Version D 2.008 Nov 27, 2007

New/Changed Features

std.string: Made munch more general and added function chompPrefix.
std.variant: Added documentation for variantArray
std.traits: Added CommonType template, fixed isStaticArray.
std.bitarray: scheduled for deprecation
std.bitmanip: new module with the content of std.bitarray plus the bitfields, FloatRep, and DoubleRep templates
std.process: Made getpid visible in Linux builds
std.math: Made nextafter visible for all floating types. Added approxEqual template.
std.contracts: Added enforce signature taking an exception
std.conv: Made conv_error a template parameterized on the types being converted.
std.stdio: Cosmetic changes.
std.system: Cosmetic changes.
std.file: Fixed bug in function dirEntries.
std.random: Major addition of engines and distributions.
std.format: Added raw ('r') format specifier for writef*.
std.path: Added rel2abs (Linux version only).
std.algorithm: new module
std.typecons: new module
std.functional: new module
std.numeric: new module
Added const/invariant structs, classes and interfaces.
Added const and invariant to IsExpressions.
Added typeof(return) type specifier.
Changed the way coverage analysis is done so it is independent of order dependencies among modules.
Revamped const/invariant.

Bugs Fixed

Bugzilla 70: valgrind: Conditional jump or move depends on uninitialised value(s) in elf_findstr
Bugzilla 71: valgrind: Invalid read of size 4 in elf_renumbersyms
Bugzilla 204: Error message on attempting to instantiate an abstract class needs to be improved
Bugzilla 1508: dmd/linux template symbol issues
Bugzilla 1651: .di file generated with -H switch does not translate function() arguments correctly
Bugzilla 1655: Internal error: ..\ztc\cgcod.c 1817
Bugzilla 1656: illegal declaration accepted
Bugzilla 1664: (1.23).stringof generates bad code
Bugzilla 1665: Internal error: ..\ztc\cod2.c 411

Version D 2.007 Oct 31, 2007

New/Changed Features

Functors now supported by std.traits.ReturnType().
Transitive const now leaves invariants intact in the tail.
Added overloadable unary * operation as opStar().
Full closure support added.
Data items in static data segment >= 16 bytes in size are now paragraph aligned.

Bugs Fixed

Variables of type void[0] can now be declared.
Static multidimensional arrays can now be initialized with other matching static multidimensional arrays.
Bugzilla 318: wait does not release thread resources on Linux
Bugzilla 322: Spawning threads which allocate and free memory leads to pause error on collect
Bugzilla 645: Race condition in std.thread.Thread.pauseAll
Bugzilla 689: Clean up the spec printfs!
Bugzilla 697: No const folding on asm db,dw, etc
Bugzilla 706: incorrect type deduction for array literals in functions
Bugzilla 708: inline assembler: "CVTPS2PI mm, xmm/m128" fails to compile
Bugzilla 709: inline assembler: "CVTPD2PI mm, xmm/m128" fails to compile
Bugzilla 718: Internal error: ../ztc/cgcod.c 562
Bugzilla 723: bad mixin of class definitions at function level: func.c:535: virtual void FuncDeclaration::semantic3(Scope*): Assertion `0' failed
Bugzilla 725: expression.c:6516: virtual Expression* MinAssignExp::semantic(Scope*): Assertion `e2->type->isfloating()' failed.
Bugzilla 726: incorrect error line for "override" mixin
Bugzilla 729: scope(...) statement in SwitchBody causes compiler to segfault
Bugzilla 1258: Garbage collector loses memory upon array concatenation
Bugzilla 1480: std.stream throws the new override warning all over the place
Bugzilla 1483: Errors in threads not directed to stderr
Bugzilla 1557: std.zlib allocates void[]s instead of ubyte[]s, causing leaks.
Bugzilla 1580: concatenating invariant based strings should work
Bugzilla 1593: ICE compiler crash empty return statement in function
Bugzilla 1613: DMD hangs on syntax error
Bugzilla 1618: Typo in std\system.d

Version D 2.006 Oct 16, 2007

New/Changed Features

Transformed all of string, wstring, and 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.
Implemented Overload Sets for functions and templates.
Added the std.getopt module that makes standards-conforming command-line processing easy.
Added the parse and assumeUnique to the std.conv module.
Added the dirEntries function to the std.file module.
Added the basename and dirname functions (which alias the less gainful names getBaseName and getDirectoryName to the std.path module.)
Added optional terminator to readln; added the convenience functions fopen and popen; added functions lines and chunks; all to the std.stdio module.
Added the munch function to the std.string module.
Fixed isStaticArray; added BaseClassesTuple, TransitiveBaseTypeTuple, ImplicitConversionTargets, isIntegral, isFloatingPoint, isNumeric, isSomeString, isAssociativeArray, isDynamicArray, isArray; all to the std.traits module.
Added the std.variant module.
Incorporated many of the Tango GC structural differences (much more to go still).
Added the std.contracts module.
Breaking change: std.stdio.writef can now only accept a format as its first argument.

Bugs Fixed

Bugzilla 1478: Avoid libc network api threadsafety issues
Bugzilla 1491: Suppress SIGPIPE when sending to a dead socket
Bugzilla 1562: Deduction of template alias parameter fails
Bugzilla 1571: Const on function parameters not carried through to .di file
Bugzilla 1575: Cannot do assignment of tuples
Bugzilla 1579: write[ln] fails for obj.toString()
Bugzilla 1580: Concatenating invariant based strings should work

Version D 2.005 Oct 1, 2007

New/Changed Features

std.math.sin, cos, tan are now evaluated at compile time if the argument is a constant.
Added Cristian Vlasceanu's idea for C++ interface for 'plugins'
Overhaul phobos linux.mak and add documentation build logic
Massive additions to std.conv
Add writeln() and write() to std.stdio

Bugs Fixed

Fix std.boxer boxing of Object's (unit test failure)
Fix std.demangle to not show hidden parameters (this and delegate context pointers)
Bugzilla 217: typeof not working properly in internal/object.d
Bugzilla 218: Clean up old code for packed bit array support
Bugzilla 223: Error message for unset constants doesn't specify error location
Bugzilla 278: dmd.conf search path doesn't work
Bugzilla 479: can't compare arrayliteral statically with string
Bugzilla 549: A class derived from a deprecated class is not caught
Bugzilla 550: Shifting by more bits than size of quantity is allowed
Bugzilla 551: Modulo operator works with imaginary and complex operands
Bugzilla 556: is (Type Identifier : TypeSpecialization) doesn't work as it should
Bugzilla 668: Use of *.di files breaks the order of static module construction
Bugzilla 1125: Segfault using tuple in asm code, when size not specified
Bugzilla 1437: dmd crash: "Internal error: ..\ztc\cod4.c 357"
Bugzilla 1456: Cannot use a constant with alias template parameters
Bugzilla 1474: regression: const struct with an initializer not recognized as a valid alias template param
Bugzilla 1488: Bad code generation when using tuple from asm
Bugzilla 1510: ICE: Assertion failure: 'ad' on line 925 in file 'func.c'
Bugzilla 1523: struct literals not work with typedef
Bugzilla 1530: Aliasing problem in DMD front end code
Bugzilla 1531: cannot access typedef'd class field
Bugzilla 1537: Internal error: ..\ztc\cgcod.c 1521

Version D 2.004 Sep 5, 2007

New/Changed Features

Added command line switches -defaultlib and -debuglib
Bugzilla 1445: Add default library options to sc.ini / dmd.conf
Changed result type of IsExpression from int to bool.
Added isSame and compiles to __traits.
Added optional TemplateParameterList to IsExpression.
Added warning when override is omitted.
Added std.hiddenfunc.
Added trace_term() to object.d to fix Bugzilla 971: No profiling output is generated if the application terminates with exit
Multiple module static constructors/destructors allowed.
Added new syntax for string literals (delimited, heredoc, D tokens)
Added __EOF__ token

Bugs Fixed

Fixed D/56414
Bugzilla 961: std.windows.registry stack corruption
Bugzilla 1315: CTFE doesn't default initialise arrays of structs
Bugzilla 1342: struct const not accepted as initializer for another struct
Bugzilla 1363: Compile-time issue with structs in 'for'
Bugzilla 1375: CTFE fails for null arrays
Bugzilla 1378: A function call in an array literal causes compiler to crash
Bugzilla 1384: Compiler segfaults when using struct variable like a function with no opCall member.
Bugzilla 1388: multiple static constructors allowed in module
Bugzilla 1414: compiler crashes with CTFE and structs
Bugzilla 1421: Stack Overflow when using __traits(allMembers...)
Bugzilla 1423: Registry: corrupted value
Bugzilla 1436: std.date.getLocalTZA() returns wrong values when in DST under Windows
Bugzilla 1446: Missing comma in Final Const and Invariant page title
Bugzilla 1447: CTFE does not work for static member functions of a class
Bugzilla 1448: UTF-8 output to console is seriously broken
Bugzilla 1450: Registry: invalid UTF-8 sequence
Bugzilla 1460: Compiler crash on valid code
Bugzilla 1464: "static" foreach breaks CTFE
Bugzilla 1468: A bug about stack overflow.

Version D 2.003 Jul 21, 2007

New/Changed Features

Added 0x78 Codeview extension for type dchar.
Moved next member from Object.Error to Object.Exception
Added ForeachRangeStatement
Added extern (System)
Added std.traits
Bugzilla 345: updated std.uni.isUniAlpha to Unicode 5.0.0

Bugs Fixed

Bugzilla 46: Included man files should be updated
Bugzilla 268: Bug with SocketSet and classes
Bugzilla 406: std.loader is broken on linux
Bugzilla 561: Incorrect duplicate error message when trying to create instance of interface
Bugzilla 588: lazy argument and nested symbol support to std.demangle
Bugzilla 668: Use of *.di files breaks the order of static module construction
Bugzilla 1110: std.format.doFormat + struct without toString() == crash
Bugzilla 1300: Issues with struct in compile-time function
Bugzilla 1306: extern (Windows) should work like extern (C) for variables
Bugzilla 1318: scope + ref/out parameters are allowed, contrary to spec
Bugzilla 1320: Attributes spec uses 1.0 const semantics in 2.0 section
Bugzilla 1331: header file genaration generates a ":" instead of ";" at pragma
Bugzilla 1332: Internal error: ../ztc/cod4.c 357
Bugzilla 1333: -inline ICE: passing an array element to an inner class's constructor in a nested function, all in a class or struct
Bugzilla 1336: Internal error when trying to construct a class declared within a unittest from a templated class.

Version D 2.002 Jul 1, 2007

New/Changed Features

Renamed linux library from libphobos.a to libphobos2.a

Bugs Fixed

Bugzilla 540: Nested template member function error - "function expected before ()"
Bugzilla 559: Final has no effect on methods
Bugzilla 627: Concatenation of strings to string arrays with ~ corrupts data
Bugzilla 629: Misleading error message "Can only append to dynamic arrays"
Bugzilla 639: Escaped tuple parameter ICEs dmd
Bugzilla 641: Complex string operations in template argument ICEs dmd
Bugzilla 657: version(): ignored
Bugzilla 689: Clean up the spec printfs!
Bugzilla 1103: metastrings.ToString fails for long > 0xFFFF_FFFF
Bugzilla 1107: CodeView: wrong CV type for bool
Bugzilla 1118: weird switch statement behaviour
Bugzilla 1186: Bind needs a small fix
Bugzilla 1199: Strange error messages when indexing empty arrays or strings at compile time
Bugzilla 1200: DMD crash: some statements containing only a ConditionalStatement with a false condition
Bugzilla 1203: Cannot create Anonclass in loop
Bugzilla 1204: segfault using struct in CTFE
Bugzilla 1206: Compiler hangs on this() after method in class that forward references struct
Bugzilla 1207: Documentation on destructors is confusing
Bugzilla 1211: mixin("__LINE__") gives incorrect value
Bugzilla 1212: dmd generates bad line info
Bugzilla 1216: Concatenation gives 'non-constant expression' outside CTFE
Bugzilla 1217: Dollar ($) seen as non-constant expression in non-char[] array
Bugzilla 1219: long.max.stringof gets corrupted
Bugzilla 1224: Compilation does not stop on asserts during CTFE
Bugzilla 1228: Class invariants should not be called before the object is fully constructed
Bugzilla 1233: std.string.ifind(char[] s, char[] sub) fails on certain non ascii strings
Bugzilla 1234: Occurrence is misspelled almost everywhere
Bugzilla 1235: std.string.tolower() fails on certain utf8 characters
Bugzilla 1236: Grammar for Floating Literals is incomplete
Bugzilla 1239: ICE when empty tuple is passed to variadic template function
Bugzilla 1242: DMD AV
Bugzilla 1244: Type of array length is unspecified
Bugzilla 1247: No time zone info for India
Bugzilla 1285: Exception typedefs not distinguished by catch
Bugzilla 1287: Iterating over an array of tuples causes "glue.c:710: virtual unsigned int Type::totym(): Assertion `0' failed."
Bugzilla 1290: Two ICEs, both involving real, imaginary, ? : and +=.
Bugzilla 1291: .stringof for a class type returned from a template doesn't work
Bugzilla 1292: Template argument deduction doesn't work
Bugzilla 1294: referencing fields in static arrays of structs passed as arguments generates invalid code
Bugzilla 1295: Some minor errors in the lexer grammar

Version D 2.001 Jun 27, 2007

New/Changed Features

Added D_Version2 predefined identifier to indicate this is a D version 2.0 compiler
Added __VENDOR__ and __VERSION__.
Now an error to use both const and invariant as storage classes for the same declaration
The .init property for a variable is now based on its type, not its initializer.

Bugs Fixed

std.compiler now is automatically updated.
Fixed problem catting mutable to invariant arrays.
Fixed CFTE bug with e++ and e--.
Bugzilla 1254: Using a parameter initialized to void in a compile-time evaluated function doesn't work
Bugzilla 1256: "with" statement with symbol
Bugzilla 1259: Inline build triggers an illegal error msg "Error: S() is not an lvalue"
Bugzilla 1260: Another tuple bug
Bugzilla 1261: Regression from overzealous error message
Bugzilla 1262: Local variable of struct type initialized by literal resets when compared to .init
Bugzilla 1263: Template function overload fails when overloading on both template and non-template class
Bugzilla 1268: Struct literals try to initialize static arrays of non-static structs incorrectly
Bugzilla 1269: Compiler crash on assigning to an element of a void-initialized array in CTFE
Bugzilla 1270: -inline produces an ICE
Bugzilla 1272: problems with the new 1.0 section
Bugzilla 1274: 2.0 beta link points to dmd.zip which is the 1.x chain
Bugzilla 1275: ambiguity with 'in' meaning
Bugzilla 1276: static assert message displayed with escaped characters
Bugzilla 1277: "in final const scope" not considered redundant storage classes
Bugzilla 1279: const/invariant functions don't accept const/invariant return types
Bugzilla 1280: std.socket.Socket.send (void[],SocketFlags) should take a const(void)[] instead
Bugzilla 1283: writefln: formatter applies to following variable
Bugzilla 1286: crash on invariant struct member function referencing globals

Version D 2.000 Jun 17, 2007

New/Changed Features

Added aliases string, wstring, and dstring for strings.
Added .idup property for arrays to create invariant copies.
Added const, invariant, and final.
in parameter storage class now means final scope const.
foreach value variables now default to final if not declared as inout.
class and struct invariant declarations now must have a ().

Bugs Fixed

Added missing \n to exception message going to stderr.
Fixed default struct initialization for CTFE.
Bugzilla 1226: ICE on a struct literal

D Home

Documentation

Community

Change Log

Language Changes

Language Enhancements

Compiler Enhancements

Phobos Changes

Phobos Enhancements

Language Changes

Rationale:

Rationale:

Rationale:

Rationale:

Rationale:

Rationale:

Language Enhancements

Rationale:

Limitations:

Compiler Enhancements

Phobos Changes

Phobos Enhancements

Language Changes

DMD Compiler regressions

DMD Compiler bugs

DMD Compiler enhancements

Phobos regressions

Phobos bugs

Phobos enhancements

Druntime bugs

Website regressions

Website bugs

Website enhancements

New/Changed Features

Bugs Fixed

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

New/Changed Features

Bugs Fixed

New/Changed Features

Bugs Fixed

New/Changed Features

Bugs Fixed

New/Changed Features

Bugs Fixed

New/Changed Features

Bugs Fixed

New/Changed Features

Bugs Fixed

New/Changed Features