Change Log

Compiler Changes

1. Warning: Change in helper function generation might cause link error.
2. The new -profile=gc switch enables profiling memory allocation.
3. unittest blocks no longer parsed unless -unittest is specified.
4. Compiler generated inclusive destructor and postblit functions for UDTs are now accessible as .__xdtor and .__xpostblit, see dmd#4650.

Language Changes

1. pragma(inline) was added.
2. attribute inference for auto functions
3. Indexed type tuples can now be followed by dot identifiers.
4. Support template parameter deduction from function default arguments.
5. Invalid reinterpret casts can be detected in the frontend.

Library Changes

1. Many phobos functions were rangified.
2. std.typetuple was renamed to std.meta but a backwards compatible forwarding module will remain.
3. TypeTuple was renamed to AliasSeq but a backwards compatible alias will remain.
4. hexString was added to replace core language hex strings.
5. hasUDA was added to help check for the existence of user-defined attributes on symbols.
6. GC API calls can now be profiled separately.
7. The runtime implementations of synchronized and synchronized (obj) were rewritten to fix a race condition during mutex initialization, see druntime#1274.
8. The handwritten object.di header was replaced by directly using the object.d source file, see druntime#1222 for more details.
9. The AA implementation now uses open addressing.
10. Merging code coverage reports was fixed, see Bugzilla 14464 and dmd_coverSetMerge.
11. executeShell now ignores the SHELL environment variable and always uses sh, see Bugzilla 14282.
12. byLine was improved to use getdelim where available and is now up to 3x faster, see Bugzilla 11810.
13. The newly added ordered and strictlyOrdered can be used to test whether a few given values are ordered.
14. RefCounted uses the new return attribute to enable escape checking for it's payload.

Compiler Changes

1. Warning: Change in helper function generation might cause link error.

   In order to fix Issue 14828 compiler helper functions for array bounds checking and assert are now generated only once when a module is compiled, not everytime they are used. This may lead to link errors when using a module without compiling and linking against it.

   If you encounter link errors like

   undefined reference to '_D5mylib5mymod7__arrayZ'

   undefined reference to '_D5mylib5mymod8__assertFiZv'

   undefined reference to '_D5mylib5mymod15__unittest_failFiZv'

   then you're not compiling and/or not linking the module mylib.mymod.

2. The new -profile=gc switch enables profiling memory allocation.

   When compiling with -profile=gc dmd will instrument GC allocations to be traced by the runtime. The runtime accumulates the traces and writes a report to the file profilegc.log upon program termination.

   Example:

   bytes allocated, type, function, file:line
        171	immutable(char)[] example.concat example.d:4
         24	closure D main example.d:18
         16	example.Klass D main example.d:20
               

   Note: GC allocations using the core.memory interface are not profiled.

3. unittest blocks no longer parsed unless -unittest is specified:

   When the unittest code is not necessary, it will be merely analyzed as the tokens enclosed with paired braces, to speed up compilation speed.

   unittest { auto r = test(); assert(r); }
   // If you don't specify -unittest, no AST generated for the unittest block.
   
   unittest { the contents is just ignored. }
   // Since 2.067: this had caused parsing error.
   //  From 2.068: no error happens, because it's equivalent with:
   enum unittest_code = q{ the contents is just ignored. };
   

Language Changes

1. Many phobos functions were rangified.

   Many phobos functions that allocated GC memory were changed to support ranges or were complemented by an alternative supporting ranges. Using ranges often eliminates GC allocations.

   setExtension("foo.jpg", ".png"); // allocates a new string
   withExtension("foo.jpg", ".png"); // returns a range without allocating
   

   Rangified Functions:

   Module	Functions
   std.algorithm.comparison	levenshteinDistance
   std.path	asAbsolutePath asNormalizedPath asRelativePath chainPath dirName driveName filenameCmp globMatch isValidFilename isValidPath pathSplitter rootName stripExtension withDefaultExtension withExtension
   std.string	centerJustifier chomp chompPrefix chop column detabber entabber indexOf leftJustifier makeTransTable rightJustifier soundexer strip stripLeft stripRight
   std.uni	asCapitalized asLowerCase asUpperCase

2. pragma(inline) was added:

   A new pragma was added for more fine-grained control of inlining. It must be used together with the -inline switch.

   pragma(inline, true) // errors if function isn't inlined
   int double(int val) { return 2 * val; }
   

   pragma(inline, false) // never inline
   int double(int val) { return 2 * val; }
   

   Read the documentation for more details.

3. Attributes for auto return function are now inferred.

   Just like templated functions, functions with an auto return type must always have a function body. The compiler was changed to take advantage of this fact and now also infers attributes for them.

   auto foo()() {} // template function
   auto bar() {}   // non-template function without return type
   void baz() {}   // non-template function with return type
   
   static assert(is(typeof(&foo!()) == void function() pure nothrow @nogc @safe));
   static assert(is(typeof(&bar) == void function() pure nothrow @nogc @safe));
   static assert(is(typeof(&baz) == void function()));
   

4. Indexed type tuples can now be followed by dot identifiers.

   A parsing limitation was lifted and it's now possible to use an indexed type tuple followed by dot identifiers as typename.

   alias TypeTuple(T...) = T;
   
   struct S
   {
       alias T = int;
       alias U = TypeTuple!(long, string);
   }
   
   alias Types = Tuple!(S, S);
   
   Types[0].T a;     // Types[0] == S, then typeof(a) == S.T == int
   Types[0].U[1] b;  // Types[0].U == S.U, then typeof(b) == S.U[1] == string
   

5. Support template parameter deduction from function default arguments:

   When performing IFTI templated types can now be deduced from a parameter's default argument. This avoids a redundant and error prone declaration of the default type.

   void previously(T=int)(T t = 0) { } // it was necessary to also specify a default type
   void now(T)(T t = 0) { } // the default type can be deduced from the default argument as int
   void main() { previously(); now(); }
   

6. Invalid reinterpret casts can be detected in the frontend.

   Invalid reinterpret casts are now detected in the compiler frontend instead of the backend. This allows to check for possible reinterpret casts during compile time and improves the error messages for invalid casts.

   pragma(msg, is(typeof({ void* x; auto y = cast(void delegate())x; })));
   // Since 2.067: it prints 'true'
   //  From 2.068: it prints 'false'
   
   void test() { void* x; auto y = cast(void delegate())x; }
   // Since 2.067: it had reported internal compiler error "Error: e2ir: cannot cast ..."
   //  From 2.068: it reports proper frontend error.
   

Library Changes

1. GC API calls can now be profiled separately.

   The GC option --DRT-gcopt=profile has been enhanced to accept an additional level 2 that allows profiling API calls grouped by most common operations.

   As this instrumentation has an impact on the GC performance even if unused, you have to recompile the GC module with -debug=PROFILE_API, e.g.

   dmd test.d -O -inline -debug=PROFILE_API -Ipath-to-druntime/src path-to-druntime/src/gc/gc.d
   ./test --DRT-gcopt=profile:2
   

   The profiling summary will then look like this:

       malloc:  9768628 calls, 531 ms
       realloc: 0 calls, 0 ms
       free:    0 calls, 0 ms
       extend:  1100 calls, 0 ms
       other:   826 calls, 0 ms
       lock time: 160 ms
       GC API: 692 ms
   GC summary:   12 MB,   52 GC  331 ms, Pauses  227 ms <    4 ms API  692 ms
   

   The malloc function includes time for GC collections. Lock time (GC synchronization) is measured separately and not included in the other times.

2. The AA implementation now uses open addressing.

   The runtime implementation for associative arrays was rewritten and now uses open addressing with quadratic probing and triangular numbers. This is much more cache friendly than the old separate chaining implementation and can result in ~25% faster lookups for big AAs. Also see druntime#1229.

   

   Note: As the allocation pattern changed (the table is bigger, nodes are smaller) you might see a small drop in performance because the GC manages big allocations less efficiently.

DMD Compiler regressions

1. Bugzilla 9279: [REG2.055/2.063] Static array return value implicitly converted to immutable dynamic array
2. Bugzilla 12984: [REG2.068a] ICE on forward reference of derived class from other instantiated class
3. Bugzilla 13816: [REG2.066.0] The compiler crashes with recursive tuple expansion
4. Bugzilla 14207: [REG2.065] [CTFE] ICE on unsupported reinterpret cast in compile time
5. Bugzilla 14351: [REG2.063] inout base class constructor can't be called
6. Bugzilla 14390: [REG2.068a] ICE or bad "has forward references" error with circular class structure
7. Bugzilla 14406: [REG2.068a] GIT HEAD ignores forward reference and generates wrong code
8. Bugzilla 14430: [REG2.060] Null parameter is detected as non-null.
9. Bugzilla 14468: [Reg 2.068.0-devel] overload mismatch for template instance with typesafe variadic parameter
10. Bugzilla 14481: [REG2.066] ICE with forward reference of manifest constant on template arguments
11. Bugzilla 14520: [REG2.067.0] string/alias template overload
12. Bugzilla 14528: [REG2.058a] can't pass protected member to template by alias
13. Bugzilla 14546: "ClockType.uptime is not supported by MonoTimeImpl on this system"
14. Bugzilla 14549: isVirtualMethod does not work well with Github DMD
15. Bugzilla 14552: [REG2.066] SIGSEGV with compile construction nested class in predicate
16. Bugzilla 14556: [REG2.067] can't instantiate struct that has constructor and static array of enum
17. Bugzilla 14560: [REG2.058] Strange -inline behavior
18. Bugzilla 14568: [REG2.067] gaggederrors ICE
19. Bugzilla 14571: [REG2.064] Large static arrays seem to lock up DMD
20. Bugzilla 14572: cannot build dmd from source anymore: 'g++ -m64: No such file or directory'
21. Bugzilla 14573: [REG2.067] Extreme memory usage when synchronized( object ) is used
22. Bugzilla 14587: [REG2.064] generated 64 bit code for switch jump tables is wrong
23. Bugzilla 14594: [REG2.068a] DDoc for template functions and structs has disappeared
24. Bugzilla 14606: [REG2.067.0] Bad code with -inline and structs
25. Bugzilla 14609: [REG2.068a] Github HEAD: DMD assertion failure for valid code
26. Bugzilla 14610: [REG2.067] 'null this' assertion missing in 2.067
27. Bugzilla 14634: dmd crashes without any input
28. Bugzilla 14642: [REG2.066] ICE in ctfeInterpret
29. Bugzilla 14666: [REG2.061] Bogus forward reference error
30. Bugzilla 14672: [REG2.067.0] Internal error: e2ir.c 4620 when copying array of derived class to an array of base class
31. Bugzilla 14805: [REG2.064] Unreasonably slow "new Struct[large]"
32. Bugzilla 14806: [REG2.063] alias this doesn't force elaborate equality, but is followed during it
33. Bugzilla 14814: ld: GOT load reloc does not point to a movq instruction
34. Bugzilla 14828: [REG2.067] duplicate symbol __ModuleInfoZ depending on ordering of files passed to dmd
35. Bugzilla 14829: [REG2.066.0] wrong code with -O -inline
36. Bugzilla 14834: [REG 2.068-b2] dirEntries with mask stopped working with "-inline -debug"
37. Bugzilla 14836: [REG2.068a] Multiple variadic template argument trick broken
38. Bugzilla 14838: [REG 2.066] Wrong attribute inference for auto-generated class destructor with static array of non-POD type
39. Bugzilla 14844: [REG2.068a] __traits(allMembers) must not visit yet not instantiated template members
40. Bugzilla 14851: [REG2.068.0-b2] Cannot assign array operation result to static array variable
41. Bugzilla 14853: [REG2.066] DMD segfaults with the cast from mutable struct new to shared
42. Bugzilla 14890: [REG 2.068.0-rc1] Can not construct a RedBlackTree of Tuples

DMD Compiler bugs

1. Bugzilla 1759: Closures and With Statements
2. Bugzilla 2803: template + default argument = doesn't work
3. Bugzilla 3869: Unreasonable error without line number: "recursive template expansion"
4. Bugzilla 5770: Template constructor bypass access check
5. Bugzilla 6613: Can't use empty tuple as default value for variadic template function parameter
6. Bugzilla 6766: Forward reference error for default struct/class arguments
7. Bugzilla 8217: static nested class can reference outer scope by template instantiation
8. Bugzilla 8234: symbols used in CTFE affect the function literal type
9. Bugzilla 9023: CTFE: cannot use ~= on an empty AA.
10. Bugzilla 10158: 'offsetof' property of nested struct does not work properly
11. Bugzilla 10282: Refused assignment of vector op result to const array
12. Bugzilla 10492: Illegal Instruction for mixin template with scope declarations
13. Bugzilla 10972: aggregate postblit doesn't clean up in case of failure
14. Bugzilla 11166: Forward reference error when alias of template instance is private
15. Bugzilla 12036: Wrong code with auto-returning function as mixin alias param
16. Bugzilla 12152: Cannot forward reference subclass member in superclass
17. Bugzilla 12406: Broken delegate closure
18. Bugzilla 12603: [CTFE] goto does not correctly call dtors
19. Bugzilla 12799: Forward reference to nested enum with struct.sizeof
20. Bugzilla 12971: Missing REX prefix for 8 bit register access
21. Bugzilla 13270: ddoc can't find parameters of ditto'd function overloads
22. Bugzilla 13920: DMD crash when trying to set a delegate from __traits(getOverloads)
23. Bugzilla 13985: Wrong code when using "super" to call final interface method
24. Bugzilla 14097: root/async.c: use after free
25. Bugzilla 14185: [ICE] [mtype.c] compiler segfault in in Type::aliasthisOf
26. Bugzilla 14243: mixin template scope inconsistency?
27. Bugzilla 14249: Loose error check for incorrect template mixin
28. Bugzilla 14264: Destructor not called when struct is returned from a parenthesis-less function call
29. Bugzilla 14268: Win64: debug info for associative arrays have no type information
30. Bugzilla 14281: duplicate .debug_info entries for arrays, delegates and aa's
31. Bugzilla 14290: is-expression accepts instantiation of already instantiated template
32. Bugzilla 14320: Improve diagnostic message for "undefined identifier" error
33. Bugzilla 14321: Unnecessary destructor call with and AA's
34. Bugzilla 14325: [CTFE] Comparison of AAs makes wrong result
35. Bugzilla 14330: Wrong DWARF type of dynamic array variable
36. Bugzilla 14343: Postfix increment doesn't work on structs with immutable member
37. Bugzilla 14348: typeof(x).ident is not accepted as a symbol
38. Bugzilla 14352: Two goto cases in one case branch does not work correctly
39. Bugzilla 14357: Match on specType does not check the conflict with already deduced template arguments
40. Bugzilla 14371: [CTFE] Binary assignment expression makes wrong result in compile-time
41. Bugzilla 14388: ICE with idup-ed struct literal in template argument
42. Bugzilla 14398: Segfault when nested struct in static array accesses context
43. Bugzilla 14407: No protection and attributes check for class/struct allocator in NewExp
44. Bugzilla 14409: false positive "Error: one path skips constructor"
45. Bugzilla 14416: .sizeof yields 1 for uninstantiated struct templates
46. Bugzilla 14425: Indirect template instantiation within is expression causes missing linker symbols
47. Bugzilla 14446: ICE on invalid import
48. Bugzilla 14510: Bad tail call optimization with static arrays
49. Bugzilla 14596: Error: e2ir: cannot cast malloc(42u) of type void* to type char[]
50. Bugzilla 14617: PTHREAD_MUTEX_INITIALIZER does not work on OSX
51. Bugzilla 14629: Type system breaking and wrong code bugs in casting reference types to typeof(null)
52. Bugzilla 14649: ICE on invalid array operation with string literals
53. Bugzilla 14656: "auto" of "auto ref" spills over to other function

DMD Compiler enhancements

1. Bugzilla 9914: Do attribute inference for auto functions
2. Bugzilla 11003: Improve .di generation
3. Bugzilla 14465: CTFE exception stacktrace shows location of Exception constructor
4. Bugzilla 14547: Ddoc should prefer new Variable Template syntax

Phobos regressions

1. Bugzilla 14712: GIT HEAD : std.net.curl regressions
2. Bugzilla 14748: Removing std.stdio import causes 2x increase in "Hello, world" program binary filesize
3. Bugzilla 14765: [Reg2.068.0] Rangified functions no longer accept types that implicitly cast to string
4. Bugzilla 14842: [REG 2.068-b2] approxEqual does not work with integers
5. Bugzilla 14881: [REG] posix.mak omits package.d files when building zip file

Phobos bugs

1. Bugzilla 12702: [FixIncluded] std.container.RedBlackTree's in operator is not const
2. Bugzilla 13534: std.variant can violate memory safety
3. Bugzilla 14282: executeShell should use sh and ignore the SHELL env variable
4. Bugzilla 14373: std.range.refRange doesn't work on mere input ranges
5. Bugzilla 14408: std.process: Can't start interactive process from Windows GUI application
6. Bugzilla 14422: std.process: Pipes do not append to files on Win64
7. Bugzilla 14469: file.readText on Win64 doesn't work for files > 4GB.
8. Bugzilla 14526: GetOptException DDOC needs cleanup
9. Bugzilla 14544: isForwardRange failed to recognise valid forward range
10. Bugzilla 14575: compile error with std.range.refRange when front/back isn't implicitly convertible from const to mutable
11. Bugzilla 14585: destructor called on garbage in std.variant

Phobos enhancements

1. Bugzilla 14194: nothrow emplace for classes needed
2. Bugzilla 14288: std.windows.registry should use std.windows.syserror
3. Bugzilla 14289: WindowsException should not attempt to parse code 0
4. Bugzilla 14368: stdio.rawRead underperforms stdio
5. Bugzilla 14432: move construction for RefCounted
6. Bugzilla 14457: Algebraic does not allow assignment from subset type
7. Bugzilla 14535: std.net.curl.CurlException should include status line
8. Bugzilla 14548: std.stdio.File should have sync() method (fsync/FlushFileBuffers wrapper)
9. Bugzilla 14586: can't get an immutable value from a const std.variant.Variant

Druntime regressions

1. Bugzilla 14626: [REG2.066] byValue doesn't work with inout AA
2. Bugzilla 14746: [REG2.068a] Behavior change with struct destructor and alias this
3. Bugzilla 14863: CLOCK_BOOTTIME should be optional to support <2.6.39 kernels

Druntime bugs

1. Bugzilla 6607: critical_.d and critical.c use double check locking the wrong way
2. Bugzilla 12289: incorrect core.stdc.stdio.fpos_t alias
3. Bugzilla 14350: Unit test failures are not displayed in Windows GUI programs
4. Bugzilla 14401: typeid(shared X).init is empty for class types
5. Bugzilla 14423: struct destructors not finalized for AA values
6. Bugzilla 14464: coverage merge doesn't work
7. Bugzilla 14476: core.thread unit tests failing on FreeBSD 9+
8. Bugzilla 14511: Profiler does not work with multithreaded programs
9. Bugzilla 14565: dmd -profile produces garbled output for long-running CPU-intensive processes

Druntime enhancements

1. Bugzilla 12891: add atomicFetchAdd and atomicFetchSub to core.atomic
2. Bugzilla 14385: AA should use open addressing hash

dlang.org bugs

1. Bugzilla 12803: __traits(getFunctionAttributes) is not documented
2. Bugzilla 13527: ddoc website documentation does not match the current built-in symbols
3. Bugzilla 14079: Variable templates' documentation not generated.
4. Bugzilla 14080: No mention of documented unittests on ddoc's page
5. Bugzilla 14326: syntax highlighting of dpl-docs no longer works
6. Bugzilla 14418: D-style Variadic Function example does not compile

Tools bugs

1. Bugzilla 13758: RDMD renames directory if -ofNAME is the name of a directory
2. Bugzilla 14259: rdmd: --build-only / -of / -od incompatible with --dry-run

Installer bugs

1. Bugzilla 14801: OS X installer not compatible with OS X 10.11
2. Bugzilla 14864: windows uninstall during installation pops up spurious warning

DMD Compiler regressions

1. Bugzilla 14344: [REG2.067] Wrong opBinary call in construction
2. Bugzilla 14376: [REG2.064] false positive "Error: one path skips field"
3. Bugzilla 14395: [REG2.067] Typesafe variadic function call collapsed if being used for default value
4. Bugzilla 14424: [REG2.066] dmd crashes with __traits(getUnitTests)
5. Bugzilla 14440: [REG2.067] [CTFE] Wrong values set in a matrix constructor
6. Bugzilla 14443: [REG2.067.0] Incorrect double freeing of reference counted struct
7. Bugzilla 14463: [REG2.067] DMD crashes compiling module level immutable struct that takes an array in ctor

DMD Compiler bugs

1. Bugzilla 14375: static assert leads to __traits(allMembers) retuning an extra empty entry

Phobos regressions

1. Bugzilla 14396: [REG2.066] compile error std.conv.parse!int with input range

Druntime regressions

1. Bugzilla 14467: arr.capacity sometimes erroneously returns 0

Website bugs

1. Bugzilla 14329: [2.067] offline doc - menu broken due to missing jquery-1.7.2.min.js

Language Changes

1. Destructors for structs allocated on the heap are now invoked.
2. asm statements can now be used in pure, nothrow, @nogc, or @trusted code.
3. package protection attribute can be optionally bound to specified package
4. Sealed references were added (DIP25)
5. The with statement now observes temporary object lifetime

Library Changes

1. The garbage collector got faster.
2. volatileLoad and volatileStore intrinsics were added.
3. Experimental: The garbage collector can now be configured.
4. byKeyValue was added.
5. initOnce was added to perform thread-safe lazy initialization.

DMD Compiler regressions

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

DMD Compiler bugs

1. Bugzilla 13235: Wrong code on mutually recursive tuple type
2. Bugzilla 13204: recursive alias declaration
3. Bugzilla 13333: Incorrect error ungagging during the resolution of forward references
4. Bugzilla 12503: Bad optimization with scope(success) and return statement
5. Bugzilla 13383: wrong code with -O with ints, longs and bitwise operations
6. Bugzilla 13413: dmd does not follow symlink when searching for dmd.conf
7. Bugzilla 13323: UDA applied to import statement causes compilation to fail without error

DMD Compiler enhancements

1. Bugzilla 12567: Modules can't be marked as deprecated

Phobos regressions

1. Bugzilla 13618: removing deprecated std.metastrings module breaks code

Phobos bugs

1. Bugzilla 13313: std.datetime fails unittests on Windows

Druntime regressions

1. Bugzilla 13399: va_arg is nothrow yet may throw

Druntime bugs

1. Bugzilla 13377: core/sys/posix/syslog.d is in druntime/src but not in druntime/src/import
2. Bugzilla 13414: Static destructors not called correctly with dynamic loading

Installer regressions

1. Bugzilla 13233: Windows installer: downloading external installers (Visual D/dmc) does not work

Compiler Changes

1. -w now warns about an unused return value of a strongly pure nothrow function call.
2. -noboundscheck has been deprecated in favor of boundscheck=[on|safeonly|off].
3. -vgc was added to list GC allocation code positions in the code.
4. -vcolumns was added to display column numbers in error messages.
5. -color was added to make console output colored.

Language Changes

1. @nogc attribute was added.
2. extern (C++, namespace) was added.
3. Operator overloading for multi-dimensional slicing was added.
4. __traits(getFunctionAttributes) was added.
5. Support template parameter deduction for arguments with a narrowing conversion.
6. Read-Modify-Write operations on shared variables are now deprecated.
7. Support uniform construction syntax for built-in scalar types.

Library Changes

1. Duration.get and its wrappers have been deprecated in favor of the new Duration.split.
2. Some built-in type properties have been replaced with library functions.
3. Associative array keys now require equality instead of order comparison.

Linker Changes

Compiler Changes

1. -w now warns about an unused return value of a strongly pure nothrow function call:

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

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

   With the -w switch, the compiler will complain:

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

2. -noboundscheck has been deprecated in favor of boundscheck=[on|safeonly|off]:

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

   -boundscheck=

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

   Use -boundscheck=off to replace instances of -noboundscheck.

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

3. -vgc was added to list GC allocation code positions in the code:

   Prints all GC-allocation points. Analysis will follow the semantics of the new @nogc attribute.

4. -vcolumns was added to display column numbers in error messages:

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

   int x = missing_name;
   

   Without -vcolumns:

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

   With -vcolumns:

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

5. -color was added to make console output colored:

   Errors, deprecation, and warning messages will be colored.

Language Changes

1. @nogc attribute was added:

   @nogc attribute disallows GC-heap allocation.

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

2. extern (C++, namespace) was added:

   To represent a C++ namespace, extern (C++) now takes optional dot-chained identifiers.

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

   is equivalent with:

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

3. Operator overloading for multi-dimensional slicing was added:

   Documentation is here.

   Example code:

   struct MyContainer(E)
   {
       E[][] payload;
   
       this(size_t w, size_t h)
       {
           payload = new E[][](h, w);
       }
   
       size_t opDollar(size_t dim)()
       {
           return payload[dim].length;
       }
   
       auto opSlice(size_t dim)(size_t lwr, size_t upr)
       {
           import std.typecons;
           return tuple(lwr, upr);
       }
   
       void opIndexAssign(A...)(E val, A indices)
       {
           assert(A.length == payload.length);
   
           foreach (dim, x; indices)
           {
               static if (is(typeof(x) : size_t))
               {
                   // this[..., x, ...]
                   payload[dim][x] = val;
               }
               else
               {
                   // this[..., x[0] .. x[1], ...]
                   payload[dim][x[0] .. x[1]] = val;
               }
           }
       }
   }
   void main()
   {
       import std.stdio;
   
       auto c = MyContainer!int(4, 3);
       writefln("[%([%(%d%| %)]%|\n %)]", c.payload);
       // [[0 0 0 0]
       //  [0 0 0 0]
       //  [0 0 0 0]]
   
       c[1 .. 3,
         2,
         0 .. $] = 1;
       /*
       Rewritten as:
       c.opIndexAssign(c.opSlice!0(1, 3),
                       2,
                       c.opSlice!2(0, c.opDollar!2()));
       */
   
       writefln("[%([%(%d%| %)]%|\n %)]", c.payload);
       // [[0 1 1 0]
       //  [0 0 1 0]
       //  [1 1 1 1]]
   }
   

4. __traits(getFunctionAttributes) was added:

   This can take one argument, either a function symbol, function type, function pointer type, or delegate type. Examples:

   void foo() pure nothrow @safe;
   static assert([__traits(getFunctionAttributes, foo)] == ["pure", "nothrow", "@safe"]);
   
   ref int bar(int) @property @trusted;
   static assert([__traits(getFunctionAttributes, typeof(&bar))] == ["@property", "ref", "@trusted"]);
   

5. Support template parameter deduction for arguments with a narrowing conversion:

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

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

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

6. Read-Modify-Write operations on shared variables are now deprecated:

   Examples:

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

   Instead you should use atomicOp from core.atomic:

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

7. Support uniform construction syntax for built-in scalar types:

   Examples:

   short n1 = 1;
   auto n2 = short(1); // equivalent with n1, typeof(n2) is short
   
   auto p1 = new long(1);                  // typeof(p1) is long*
   auto p2 = new immutable double(3.14);   // typeof(p2) is immutable(double)*
   

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

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

Library Changes

1. Duration.get and its wrappers have been deprecated in favor of the new Duration.split:

   Duration.get and its wrappers, Duration.weeks, Duration.days, Duration.hours, and Duration.seconds, as well as Duration.fracSec (which served a similar purpose as Duration.get for the fractional second units) have proven to be too easily confused with Duration.total, causing subtle bugs. So, they have been deprecated. In their place, Duration.split has been added - and it's not only very useful, but it does a great job of showing off what D can do. Whereas Duration.get split out all of the units of a Duration and then returned only one of them, Duration.split splits out a Duration into the units that it's told to (which could be one unit or all of them) and returns all of them. It has two overloads, both which take template arguments that indicate which of the units are to be split out. The difference is in how the result is returned. As with most of the templates in core.time and std.datetime which take strings to represent units, Duration.split accepts "weeks", "days", "hours", "minutes", "seconds", "msecs", "usecs", "hnsecs", and "nsecs". The first overload returns the split out units as out parameters.

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

   The arguments can be any integral type (though no protection is given against integer overflow, so unless it's known that the values are going to be small, it's unwise to use a small integral type for any of the arguments). The second overload returns a struct with the unit names as its fields. Only the requested units are present as fields. All of the struct's fields are longs.

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

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

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

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

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

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

2. Some built-in type properties have been replaced with library functions:

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

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

3. Associative array keys now require equality rather than ordering:

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

   void main()
   {
       int[MyKey] aa;
   }
   
   struct MyKey
   {
       int x;
       int y;  // want to be ignored for AA key comparison
   
       int opCmp(ref const MyKey rhs) const
       {
           if (this.x == rhs.x)
               return 0;
   
           // defined order was merely unused for AA keys.
           return this.x > rhs.x ? 1 : -1;
       }
   }
   

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

   struct MyKey
   {
       int x;
       int y;  // want to be ignored for AA key comparison
   
       int opEquals(ref const MyKey rhs) const
       {
           return this.x == rhs.x;
       }
   }
   

DMD Compiler regressions

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

DMD Compiler bugs

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

DMD Compiler enhancements

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

Phobos regressions

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

Phobos bugs

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

Phobos enhancements

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

Druntime regressions

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

Druntime bugs

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

Druntime enhancements

1. Bugzilla 8409: Proposal: implement arr.dup in library
2. Bugzilla 12964: dev_t is incorrectly defined in runtime for Solaris systems
3. Bugzilla 12976: ModuleInfo should be immutable on Solaris
4. Bugzilla 12977: lf64 definitions aren't correct on Solaris
5. Bugzilla 12978: struct sigaction is too small on 32-bit solaris
6. Bugzilla 13037: SIGRTMIN and SIGRTMAX aren't correctly defined on Solaris
7. Bugzilla 13144: Add fenv support for Solaris
8. Bugzilla 13145: Need LC_ locale values for Solaris
9. Bugzilla 13146: Add missing function definitions from stdlib.h on Solaris

Installer regressions

1. Bugzilla 13004: /? option to cl.exe results in ICE
2. Bugzilla 13047: cannot stat ./icons/16/dmd-source.png: No such file or directory
3. Bugzilla 13210: libphobos2.so not being built
4. Bugzilla 13233: Windows installer: downloading external installers (Visual D/dmc) does not work

Installer bugs

1. Bugzilla 3319: DInstaller overwrites the %PATH% variable
2. Bugzilla 5732: Windows installer creates incorrect target for Start menu link
3. Bugzilla 13149: released libphobos2.a is build with PIC code

Website regressions

1. Bugzilla 12813: Parser is confused between float and UFC syntax

Website bugs

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

Website enhancements

1. Bugzilla 8103: Use case-insensitive sorting for Jump-to lists in the documentation
2. Bugzilla 12783: Adding 'Third Party Libraries' link to the navigation sidebar
3. Bugzilla 12858: Document opEquals usage in AAs

Compiler Changes

1. Extensionless D source file names can now be run when using the -run switch.

Language Changes

1. Goto jumps now cannot skip variable declarations.
2. All instantiated functions now infer their attributes.
3. Add a new type qualifier inout const.
4. Entire slicing operation of built-in tuple is now accepted.
5. Packages and module names now have no type.
6. Const and immutable fields with initializers are now deprecated.
7. Deprecate unordered floating point comparisons.
8. Deprecate .min property for floating-point types.
9. CTFE can handle overlapped union fields.
10. Add a new trait getAliasThis.
11. Mixing struct constructors and static opCall is no longer allowed.

Library Changes

1. Many functions in std.algorithm can now be used as predicates to other functions.
2. Allow std.algorithm.all to be used without a predicate.
3. Add std.uni.byGrapheme and std.uni.byCodePoint.
4. Add support for any number of arguments to std.range.only.

Linker Changes

1. Added /LARGEADDRESSAWARE to the Win32 Optlink linker.

Compiler Changes

1. Extensionless D source file names can now be run when using the -run switch:

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

   #!rdmd
   
   void main()
   {
   }
   

   Note: This does not allow an arbitrary extension, as D source files need to be proper D identifiers.

   Note: This feature is not available on Windows, as Windows does not have extensionless executable files.

   Note: When compiling, and in order to avoid the default behavior of generating an extensionless executable which would overwrite the source file, the compiler will generate "a.out" instead.

Language Changes

1. Goto jumps now cannot skip variable declarations:

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

   import std.stdio;
   
   void main()
   {
       goto Label; // Error: goto skips declaration of variable v
   
       int v = 42;
   
   Label:
       writeln(v);
   }
   

2. All instantiated functions now infer their attributes:

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

   struct S(T)
   {
       T square(T x)
       {
           T calc()
           {
               return x * x;
           }
           return calc();
       }
   
       static double pi() { return 3.141592; }
   }
   
   void main() pure @safe nothrow
   {
       S!int s;
   
       // S!int.square and its nested function calc are instantiated functions, so
       // their attributes are inferred as pure and callable from main()
       assert(s.square(2) == 4);  // ok
   
       // static member function attributes are also inferred now
       auto pi = typeof(s).pi();
   }
   

3. Add a new type qualifier inout const:

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

   inout(const(int))[] foo(bool condition, inout(int)[] x, immutable(int)[] y)
   {
       static assert(is(typeof(condition ? x : y) == inout(const(int))[]));
       return condition ? x : y;
   }
   
   void main()
   {
       int[] marr = [1,2,3];
       const(int)[] carr = [4,5,6];
       immutable(int)[] iarr = [7,8,9];
   
       // inout(const(int))[] can go back to const(int)[] or immutable(int)[].
       static assert(is(typeof(foo(true, marr, iarr)) == const(int)[]));
       static assert(is(typeof(foo(true, carr, iarr)) == const(int)[]));
       static assert(is(typeof(foo(true, iarr, iarr)) == immutable(int)[]));
   }
   

4. Entire slicing operation of built-in tuple is now accepted:

   Bugzilla 8244: cannot slice a type tuple with '[]' in locations where a type is valid:

   import std.typetuple;
   alias Types = TypeTuple!(int, double, string);
   
   // Was error in 2.064, but allowed from 2.065.
   alias Types2 = Types[];
   static assert(is(Types == Types2));
   

5. Packages and module names now have no type:

   Bugzilla 9081: Modules shouldn't have a type

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

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

6. Const and immutable fields with initializers are now deprecated:

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

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

   struct S
   {
       const int[1000] x = void;
   
       this(int n)
       {
           // Was disallowed in 2.064.
           // From 2.065 x is a field of runtime object.
           x[] = n;
       }
   }
   
   // S.sizeof had been 1 in 2.064.
   // From 2.065, field s.x occupies space in the object.
   static assert(S.sizeof == int.sizeof * 1000);
   
   void main()
   {
       S s = S(3);
   
       foreach (e; s.x)
       {
           assert(e == 3); // OK
       }
   }
   

7. Deprecate unordered floating point comparisons:

   Bugzilla 10369: Deprecate unordered floating point comparisons

8. Deprecate .min property for floating-point types:

   Bugzilla 10439: Deprecate float.min, double.min, real.min

9. CTFE can handle overlapped union fields:

   Example code:

   union U
   {
       size_t x;
       int* y;
   }
   
   bool test()
   {
       U u;
       assert(u.x == 0);
       // In here, reading u.y will cause CTFE error.
   
       u.y = [1,2,3].ptr;
       // Writing value to overlapped field u.y will make corresponding field u.x invalid.
   
       assert(u.y[0..3] == [1,2,3]);
       // u.y holds valid field and reading it is allowed
       // In here, reading u.x will cause CTFE error.
   
       u.x = 10;
       // Set value to u.x again.
       assert(u.x == 10);  // OK
       // In here, reading u.y will cause CTFE error.
   
       return true;
   }
   static assert(test());  // run CTFE
   

   Bit image reinterpretation by using two overlapped union fields is not allowed during CTFE.

10. Add a new trait getAliasThis:

    The new getAliasThis trait will return a tuple of field names which are marked as the subtypes of an aggregate type. For example:

    struct S
    {
        string var;
        alias var this;
    }
    
    static assert(__traits(getAliasThis, S)[0] == "var");
    

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

11. Mixing struct constructors and static opCall is no longer allowed:

    This was not implemented correctly and caused ambiguities.

    Example:

    struct S
    {
        this(int i) {}
    
        static S opCall()   // disallowed due to constructor
        {
            return S.init;
        }
    }
    

    Note: static opCall can be used to simulate struct constructors with no arguments, but this is not recommended practice. Instead, the preferred solution is to use a factory function to create struct instances.

Library Changes

1. Many functions in std.algorithm can now be used as predicates to other functions:

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

   import std.algorithm : all;
   import std.ascii : isDigit;
   
   void main()
   {
       string[] inputs = ["foo1", "bar2"];
   
       bool allContainDigit;
       foreach (input; inputs)
       {
           if (!any!isDigit(input))  // none of the characters are ASCII digits
           {
               allContainDigit = false;
               break;
           }
       }
   }
   

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

   import std.algorithm : any, all;
   import std.ascii : isDigit;
   
   void main()
   {
       string[] inputs = ["foo1", "bar2"];
       bool allContainDigit = all!(any!isDigit)(inputs);
   }
   

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

   import std.algorithm : any, all;
   import std.ascii : isDigit;
   
   void main()
   {
       alias isAnyDigit = any!isDigit;  // less visual noise and a self-describing function
   
       string[] inputs = ["foo1", "bar2"];
       bool allContainDigit = all!isAnyDigit(inputs);  // easier to understand
   
       alias doAllContainDigits = all!isAnyDigit;  // or wrap the entire algorithm into one symbol!
   
       assert( doAllContainDigits(["1", "a 1", "b 2"]));  // self-describing code
       assert(!doAllContainDigits(["c", "a 1", "b 2"]));
   }
   

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

   import std.algorithm : any, all;
   import std.ascii : isDigit;
   
   void main()
   {
       alias areAllDigits = all!isDigit;
   
       alias areAnyIntegrals = any!areAllDigits;
   
       assert( areAnyIntegrals(["123", "456"]));
       assert( areAnyIntegrals(["abc", "123"]));  // "123" is a number
       assert(!areAnyIntegrals(["abc", "def123"])); // "def123" is not really a number
   }
   

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

   import std.algorithm : any, all;
   import std.ascii : isDigit;
   
   void main()
   {
       alias areAllDigits = all!isDigit;
   
       alias allStringsDigits = all!areAllDigits;
   
       assert( allStringsDigits(["123", "456"]));
       assert(!allStringsDigits(["abc", "123"]));  // "123" is a number, but "abc" is not
   }
   

2. Allow std.algorithm.all to be used without a predicate.

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

   import std.algorithm;
   
   void main()
   {
       auto arr1 = [true, true, true];
       assert( all(arr1));  // all values are true
   
       auto arr2 = [false, true, true];
       assert(!all(arr2));  // all values are not true
   
       auto arr3 = [1, 2, 3];
       assert( all(arr3));  // all values convert to true
   
       auto arr4 = [0, 2, 3];
       assert(!all(arr4));  // all values do not convert to true
   }
   

3. Add std.uni.byGrapheme and std.uni.byCodePoint.

   Complementary higher-order ranges which enable range operations on graphemes:

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

   Note that byGrapheme will support bidirectionality in the future, obviating the need for array in the above example.

4. Add support for any number of arguments to std.range.only.

   only can now be used with more than one argument:

   import std.algorithm : joiner;
   import std.range : equal, only;
   
   void main()
   {
       assert(only("one", "two", "three").joiner(" ").equal("one two three"));
   }
   

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

Linker Changes

1. Added /LARGEADDRESSAWARE to the Win32 Optlink linker.

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

DMD Compiler regressions

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

DMD Compiler bugs

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

DMD Compiler enhancements

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

Phobos regressions

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

Phobos bugs

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

Phobos enhancements

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

Druntime regressions

1. Bugzilla 11478: shared library on osx: worked in 2.062, fails in 2.063.2, still fails in 2.064

Druntime bugs

1. Bugzilla 3454: Inconsistent flag setting in GC.realloc()
2. Bugzilla 4809: Stack trace when throwing exception misses location of the throw statement
3. Bugzilla 7508: float4 values aren't stored on initialisation
4. Bugzilla 8301: Access violation when a big array is allocated
5. Bugzilla 10701: [GC] segfault in GC
6. Bugzilla 11806: Freeze in GC.collect() in in-contracts when multithreading is used

Optlink regressions

1. Bugzilla 11559: Optlink crash with more than 2048 modules generated and debug info

Optlink bugs

1. Bugzilla 2837: OPTLINK and LARGEADDRESSAWARE
2. Bugzilla 3956: linker removes underscore from all exported symbols of a module but the first
3. Bugzilla 6673: Map file contains broken lines on every 16,384 bytes
4. Bugzilla 7634: optlink creates bad debug info for a large number of modules

Installer bugs

1. Bugzilla 10246: Windows installer still downloads from ftp.digitalmars.com
2. Bugzilla 11799: Incompatible argument types in create_dmd_release

Installer enhancements

1. Bugzilla 10153: Beta releases should all have unique names

Website regressions

1. Bugzilla 11449: Jump lists of phobos are in wrong order

Website bugs

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

Website enhancements

1. Bugzilla 11676: Add a link to D Wiki Sidebar to take users back to DLang.org
2. Bugzilla 12087: Add Readme to dlang.org repository that explains how to contribute

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.

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

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

Language Changes

1. Const and immutable fields with initializers are now warned about.
2. Constructor qualifiers are taken into account when constructing objects.
3. Struct members which require non-bitwise comparison are now properly compared.
4. Array copy operations now always require using the slice syntax.
5. Types no longer act as arguments in typeof expressions.
6. The index variable in a foreach range is no longer implicitly a reference.
7. Associative array entries are no longer default-initialized before assignment.
8. The const attribute is no longer inherited in overriden methods.
9. typeof(null) no longer implicitly converts to T[].
10. The Template This Parameter now changes the member function qualifier.
11. Array slices are now r-values.
12. Accessing a non-static field without a this reference is only allowed in certain contexts.
13. Arrays no longer implicitly convert to a pointer.

Language Enhancements

1. Expressions which return unique objects can be implicitly casted to immutable.
2. Static array of void can now be user-initialized.
3. Aggregates can now contain multiple invariants.
4. Methods of templated aggregates can now infer attributes.
5. is expression no longer requires an identifier.
6. Dynamic arrays of known size can be implicitly cast to static arrays in some contexts.
7. Tuples can now be void-initialized.
8. Tuples can now be compared for equality.
9. Template constraints can now be put after the inheritance list.
10. Fields with initializers can now be re-initialized in a const constructor.
11. Added the isNested trait for discovery of aggregates and functions with context pointers.
12. Templates can now be nested inside of functions.
13. UFCS now works with scoped local imports.
14. Added __FUNCTION__, __PRETTY_FUNCTION__ and __MODULE__.
15. DDoc: Deprecated declarations are now wrapped in a DEPRECATED macro.
16. Added documented unittest feature for verifiable code example generation.

Compiler Enhancements

1. Added -main switch which adds an empty main function.
2. Added -cov=percentage switch for minimal coverage tests.
3. Added ability to override the mangling of a symbol with a compiler pragma.

Phobos Changes

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

Phobos Enhancements

1. std.process has been redesigned from the ground up and introduces a new API and functionality.
2. std.getopt can now set booleans to false.
3. Added ownerTid property in std.concurrency.

Language Changes

1. Const and immutable fields with initializers are now warned about:

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

   In a future release, a new behavior for them will be enabled:

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

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

   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;  // becomes an error in a future release, 'arr' will require the 'this' reference.
   
       // S is size 1 in 2.062 and 2.063. In a future release this will change and the following static assert will pass.
       static assert(S.sizeof == size_t.sizeof + size_t.sizeof);  // ptr + length for the array
   }
   

   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.

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

3. 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.

4. 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.

5. 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.

6. 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.

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

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

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

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

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

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

13. 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

1. Expressions which return unique objects can be implicitly casted 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
   }
   

2. 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.

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

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

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

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

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

   Upon such initialization the values in the tuple are undetermined.

8. 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))
   {
   }
   

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

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

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

12. 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.

13. 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.

14. 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)'
    

15. 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
    

16. 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.

    For more information, see the documentation page of documented unittests.