Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
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 a local clone.

# Change Log: 2.064

Download D 2.064
released November 5, 2013

#### Language Enhancements

1. Introduced the ability to define and import package modules.
2. Introduced a new eponymous template syntax.
3. Postfix expressions are now allowed after a new expression.
4. Implicit Function Template Instantiation now supports enclosing type/scope deduction.
5. DDoc can now warn the user when the symbol names in a ddoc comment do not match the actual code.
6. Strings literals which are sliced are now implicitly convertible to a char pointer.
7. Templated and non-template functions can now be overloaded against each other.
8. Cross-module template declarations can now make an overload set.

#### Compiler Changes

1. Allow printing dependencies to stdout for tooling support.

#### Compiler Enhancements

1. Introduced the getUnitTests trait for retrieval and custom execution of unittests.
2. Introduced the getVirtualIndex trait to get the index of a virtual function.
3. Introduced the isOverrideFunction trait which indicates if a function is overridden or not.

#### Phobos enhancements

1. Introduced the structural typesafe conversion functions wrap and unwrap.
2. std.conv.to and std.string.format are now pure functions.
3. Introduced generic strip/stripLeft/stripRight functions.
4. Introduced an overload of std.string.translate which can take a buffer, avoiding the need for implicit memory allocations.
5. Introduced the thisExePath function to retrieve the executable path of the currently running process.
6. New API for std.regex match/replace functions.
7. Compile-time std.regex.ctRegex now supports lookaround just like run-time one.

List of all bug fixes and enhancements in D 2.064.

#### Language Enhancements

1. Introduced the ability to define and import package modules.

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

   libweb/client.d:

       module libweb.client;

       void runClient() { }

   libweb/server.d:

       module libweb.server;

       void runServer() { }

   libweb/package.d:

       module libweb;

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

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

   test.d:

       module test;

       import libweb;

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

   The following is an example of a package module of a sub-package:

   libweb/utils/package.d:

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

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

   To import this subpackage, use the standard module import declaration:

   test.d:

       module test;

       import libweb.utils;

       void main()
       {
       }

   ### Rationale:

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

2. Introduced a new eponymous template syntax.

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

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

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

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

   With the new eponymous syntax, the implementation code becomes much simpler:

       alias Tuple(T...) = T;

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

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

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

   ### Limitations:

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

3. Postfix expressions are now allowed after a new expression.

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

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

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

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

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

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

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

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

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

4. Implicit Function Template Instantiation now supports enclosing type/scope deduction:

IFTI has been improved, allowing you to write code such as the following:

    struct A
    {
        struct Foo { }
    }

    struct B
    {
        struct Foo { }
    }

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

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

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

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

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

    module my_module;

    struct A
    {
        struct B { }
    }

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

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

5. DDoc can now warn the user when the symbol names in a ddoc comment do not match the actual code:

Here is an example documented function, where the parameter names are wrongly documented:

    /**
        This is the sum function.

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

Generating the documentation with warnings enabled will emit the following:

    dmd -D -c -w test.d

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

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

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

6. Strings literals which are sliced are now implicitly convertible to a char pointer:

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

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

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

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

7. Templated and non-template functions can now be overloaded against each other:

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

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

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

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

8. Cross-module template declarations can now make an overload set:

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

    module a;

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

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

    module b;

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

    auto func(T, A...)(A args) if (is(T == string))
    {
        return 2;
    }

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

### Limitations:

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

#### Compiler Changes

1. Allow printing dependencies to stdout for tooling support:

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

The types of dependencies which are printed out are as follows:

depsImport: Module imports found (same as -deps=file output, except prefixed with depsImport)

depsVersion: Versions (except standard ones and ones set in the module itself)

depsFile: String imports found, e.g. string x = import("foo.txt");

depsLib: Libraries specified with a pragma(lib) statement

depsDebug: Any debug() statements found (except the ones set in the module itself)

#### Compiler Enhancements

1. Introduced the getUnitTests trait for retrieval and custom execution of unittests:

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

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

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

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

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

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

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

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

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

Note: You must compile with the -unittest flag to be able to retrieve the unittests.

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

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

2. Introduced the getVirtualIndex trait to get the index of a virtual function:

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

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

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

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

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

3. Introduced the isOverrideFunction trait which indicates whether or not a function is overriding:

    class Base
    {
        void foo() { }
    }

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

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

#### Phobos enhancements

1. Introduced the structural typesafe conversion functions wrap and unwrap:

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

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

    import std.typecons;

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

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

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

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

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

The wrap function can also be used with classes which define an opDispatch function, for example:

    import std.typecons;

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

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

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

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

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

You can unwrap a structurally cast object back to its original type:

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

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

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

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

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

And you can structurally cast to multiple interface types:

    import std.typecons;

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

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

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

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

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

2. std.conv.to and std.string.format are now pure functions:

Since 2.064, pure functions can take advantage of to and format. For example:

    import std.conv;
    import std.string;

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

3. Introduced generic strip/stripLeft/stripRight functions:

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

    import std.algorithm;

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

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

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

4. Introduced an overload of std.string.translate which can take a buffer, avoiding the need for implicit memory allocations:

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

    import std.array;
    import std.string;

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

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

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

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

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

5. Introduced the thisExePath function to retrieve the executable path of the currently running process:

With the thisExePath function you can retrieve the current executable path:

    import std.file;
    import std.stdio;

    void main(string[] args)
    {
        // Prints the full path of the current running executable.
        // Note: this may, or may not be the same as args[0]. The content
        // of args[0] is dependent of how the application was invoked, thisExePath()
        // is not. It's also possible to access thisExePath() from other parts of the
        // code than main.
        writeln(thisExePath());
    }

6. New API for std.regex match/replace functions:

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

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

To understand the difference in the API compare 2 samples below.

Before 2.064:

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

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

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

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

After 2.064:

    void main()
    {
        import std.regex, std.algorithm, std.range, std.stdio, std.string;
        auto m = "3.141592".matchFirst(`(\d+)\.(\d+)`);
        // m is simply a range of submatches
        assert(m.equal(["3.141592", "3", "141592"]));

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

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

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

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

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

7. Compile-time std.regex.ctRegex now supports lookaround just like run-time one:

Now ctRegex supports full syntax spectrum of run-time one except for set algebra inside of a character class. For instance, the following now compiles and passes:

    void main()
    {
        import std.regex;
        // a word, but not a title-cased ASCII
        // ?<! inside of () means "negative lookbehind"
        auto pat = ctRegex!`\w+(?<![A-Z][a-z]*)`;
        assert(!"Hello".match(pat));
        assert("good_bay".match(pat));
    }

List of all bug fixes and enhancements in D 2.064:

#### DMD Compiler regressions

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

#### DMD Compiler bugs

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

#### DMD Compiler enhancements

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

#### Phobos regressions

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

#### Phobos bugs

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

#### Phobos enhancements

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

#### Druntime regressions

1. Bugzilla 10976: thread_joinAll after main exit performed too late

#### Druntime bugs

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

#### Druntime enhancements

1. Bugzilla 9190: Vector operations are not optimized for x86_64 architecture

#### Installer bugs

1. Bugzilla 10062: installers should use CDN

#### Website bugs

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

Copyright © 1999-2020 by the D Language Foundation | Page generated by Ddoc on Tue Sep 22 09:13:40 2020