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

Change Log

Version D 2.065 Insert Date Here 1, 1

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. Add a new trait getAliasThis:
  2. 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.

  3. Many functions in std.algorithm can now be used as predicates to other functions:
  4. 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
    }
    

Library Changes

  1. Allow std.algorithm.all to be used without a predicate.
  2. 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
    }
    

Linker Changes

  1. Added /LARGEADDRESSAWARE to the Win32 Optlink linker.
  2. 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.


List of all bug fixes and enhancements:

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 11441: DMD halts compilation at semantic3
  6. Bugzilla 11447: Closure provide bogus values
  7. Bugzilla 11472: REGRESSION(2.064): dmd segfaults on wrong code instead of giving error
  8. Bugzilla 11487: dmd segfaults on writefln in nested template
  9. Bugzilla 11504: [CTFE] JSONValue cannot make in CTFE
  10. Bugzilla 11505: Bad error message: "opAssign [...] is annotated with @disable"
  11. Bugzilla 11508: [REG 2.064] Wrong code with -O on x86_64 for char comparisons
  12. Bugzilla 11513: [REG 2.064] Assertion in module.c
  13. Bugzilla 11525: REG(2.065): Error: 'a[] *= a[]' each element is not a scalar, it is a Complex!double
  14. Bugzilla 11553: dmd segfault with recursive template
  15. Bugzilla 11554: `is(T == enum);` produces an error if T is an enum defined with no members
  16. Bugzilla 11563: Module dependency cycle causes unrelated template instantiations to fail
  17. Bugzilla 11566: ICE with invalid array op
  18. Bugzilla 11596: Internal error: backend/cgcs.c 351
  19. Bugzilla 11610: Compiler core dumps on FreeBSD, compiles forever on Linux
  20. Bugzilla 11614: Error: this for _expand_field_0 needs to be type Tuple not type Foo
  21. Bugzilla 11626: [ICE] (mtype.c line 9718) With missing in ref type
  22. Bugzilla 11659: false positive goto skips initialization of variable error (skipping enum initialization)
  23. Bugzilla 11718: [REG2.065a] Unintended mangled names conflict of nested template structs
  24. Bugzilla 11723: Too many "integer overflow" errors
  25. Bugzilla 11730: associative array with Nullable!SysTime values: Called `get' on null Nullable!SysTime.
  26. Bugzilla 11751: [REG2.065a] Hex float exponents should be decimal
  27. Bugzilla 11755: Operator <>= and !<>= with arrays make internal error in e2ir
  28. Bugzilla 11767: doubly mixed-in struct "failed semantic analysis"
  29. Bugzilla 11776: [ICE] Assertion failure: 'tf->next == NULL' on line 119 in file 'mangle.c'
  30. Bugzilla 11777: [ICE] dmd memory corruption as `Scope::pop` `free`s `fieldinit` used also in `enclosing`
  31. Bugzilla 11805: Removal of Bool has critically broken expression evaluation
  32. Bugzilla 11818: Ternary operator not allowed in a value parameter anymore
  33. Bugzilla 11844: ICE(template.c:6643) Assertion failed: (td->semanticRun != PASSinit)
  34. Bugzilla 11849: Recursive enum causes segfault
  35. Bugzilla 11852: RDMD broken on the Github HEAD
  36. Bugzilla 11854: Git-head does not build with Visual Studio
  37. Bugzilla 11863: std.conv.to!string(int/uint, radix) returns incorrect string
  38. Bugzilla 11868: ICE(template.c) on passing `inout const` argument as TemplateTupleParameter

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

DMD Compiler enhancements

  1. Bugzilla 6930: combined type of immutable(T) and inout(T) should be inout(const(T))
  2. Bugzilla 10199: labels cannot be used without a statement
  3. Bugzilla 11365: Allow D source file names to have no extension (or an arbitrary extension) when -run is used
  4. Bugzilla 11417: rotate with immediate not recognized by optimizer
  5. Bugzilla 11510: Relax restriction for overlapped pointer field access in safe code/during CTFE
  6. Bugzilla 11533: Compiler should allow to being nested for static local template functions
  7. Bugzilla 11546: string import dependency failure
  8. Bugzilla 11711: Add __traits(getAliasThis)
  9. Bugzilla 11759: Poor error message trying to use lowercase L in literal suffix.
  10. Bugzilla 11840: Show all errors of undefined identifier used in a line

Phobos regressions

  1. Bugzilla 11309: std.concurrency: OwnerTerminated message doesn't work
  2. Bugzilla 11512: Can't build Phobos docs with win32 makefile
  3. Bugzilla 11527: JSONValue cannot set values through named fields
  4. Bugzilla 11528: appender: crash with -inline -O
  5. Bugzilla 11576: std.algorithm.remove!(SwapStrategy.unstable) overruns array bounds
  6. Bugzilla 11583: bigint bug
  7. Bugzilla 11591: std.typecons.Tuple -s with classes fails at runtime as associative array keys
  8. Bugzilla 11603: std.algorithm.canFind does not work when needle is 1-byte zero
  9. Bugzilla 11671: ctRegex broken
  10. Bugzilla 11684: SIGSEGV with ld.bfd version 2.22
  11. Bugzilla 11692: can't set file attributes for std.zip.ArchiveMember
  12. Bugzilla 11764: [REG2.065a]std.getopt broken
  13. Bugzilla 11831: std.zip no longer allows setting madeVersion field in zip file
  14. Bugzilla 11838: Missing emplace import for std.range.zip?
  15. Bugzilla 11853: Tuples fail "isAssignable"

Phobos bugs

  1. Bugzilla 2162: Access violation when threads run closures
  2. Bugzilla 4301: BigInt * const(BigInt) doesn't work well
  3. Bugzilla 4673: Bug in std.string (isNumeric)
  4. Bugzilla 4874: std.numeric.dotProduct doesn't work with bigints
  5. Bugzilla 5280: to!FP(Hex float string) doesn't work well
  6. Bugzilla 5762: getopt: short option parameter read incorrectly when bundling enabled
  7. Bugzilla 5977: String splitting with empty separator
  8. Bugzilla 6730: std.algorithm.splitter conflicts with std.array.splitter
  9. Bugzilla 7689: splitter() on ivalid UTF-8 sequences
  10. Bugzilla 8013: splitter() and split() give different results
  11. Bugzilla 8203: Use of std.regex.match() generates "not enough preallocated memory" error
  12. Bugzilla 8291: dirEntry cannot handle root directories + unhandled exception causes crash
  13. Bugzilla 8877: std.encoding.transcode is extremely slow
  14. Bugzilla 9528: std.array.appender can't append elements with const members
  15. Bugzilla 9645: std.algorithm.splitter on string with char as separator performs badly in certain situations
  16. Bugzilla 9823: Delegate accepting element not accepted in std.range.put
  17. Bugzilla 10569: std.traits: EnumMembers, isExpressionTuple, isTypeTuple & Largest balks at large input
  18. Bugzilla 10571: formattedWrite error with delegate and string
  19. Bugzilla 10864: [REG 2.064][PERFORMANCE] new Safe appender is slower than "~="
  20. Bugzilla 11005: std.xml does not encode attributes
  21. Bugzilla 11112: Unable to execute shell commands in different threads
  22. Bugzilla 11403: functions in std.algo can't be used as pred
  23. Bugzilla 11459: std.container.Array bool constraint ambiguity
  24. Bugzilla 11568: can't compile std.stdio.rawWrite with -m64 in Windows
  25. Bugzilla 11600: to!BigInt(string) accepts non-numeric input
  26. Bugzilla 11606: Cannot instantiate Tuple of non printable
  27. Bugzilla 11617: std.uni.normalize doesn't compile
  28. Bugzilla 11652: Support numerical ^^ complex operations in std.complex
  29. Bugzilla 11681: std.datetime.IntervalRange.opAssign with non-ref parameter is required
  30. Bugzilla 11691: can't join pathSplitter with dirSeparator
  31. Bugzilla 11713: std.string munch() does not properly handle UTF strings.
  32. Bugzilla 11738: partialShuffle actually shuffles the entire input
  33. Bugzilla 11771: Unicode set intersection with char is broken
  34. Bugzilla 11775: std.regex should check for valid repetition range in assert mode
  35. Bugzilla 11780: RangeError in format for incomplete format specifier
  36. Bugzilla 11808: std.uni.CodepointSet('А', 'Я'+1, 'а', 'я'+1) asserts
  37. Bugzilla 11839: std.regex capture group names should allow numbers to be in them

Phobos enhancements

  1. Bugzilla 5611: back() and front() with ref return + opSlice() in sort() constraint
  2. Bugzilla 11770: std.regex.Captures should be convertible to bool
  3. Bugzilla 11789: No setAttributes to complement getAttributes
  4. 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

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 7634: optlink creates bad debug info for a large number of modules

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 11579: dlang.org repo can't be built without git
  6. 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
Version D 2.064 November 5, 2013

Language Enhancements

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

Compiler Changes

  1. Allow printing dependencies to stdout for tooling support.

Compiler Enhancements

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

Phobos enhancements

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

List of all bug fixes and enhancements in D 2.064.

Language Enhancements

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

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

    libweb/client.d:

    module libweb.client;
    
    void runClient() { }
    

    libweb/server.d:

    module libweb.server;
    
    void runServer() { }
    

    libweb/package.d:

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

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

    test.d:

    module test;
    
    import libweb;
    
    void main()
    {
        startServer();
        startClient();
    }
    

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

    libweb/utils/package.d:

    module libweb.utils;  // fully qualified name of the package, not just "utils"!
    
    // publicly import modules from within the 'libweb.utils' package.
    public import libweb.utils.conv;
    public import libweb.utils.text;
    

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

    test.d:

    module test;
    
    import libweb.utils;
    
    void main()
    {
    }
    

    Rationale:

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

  2. Introduced a new eponymous template syntax.

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

    template Tuple(T...) { alias Tuple = T; }
    
    template isIntOrFloat(T)
    {
        static if (is(T == int) || is(T == float))
            enum isIntOrFloat = true;
        else
            enum isIntOrFloat = false;
    }
    
    void main()
    {
        alias Tup = Tuple!(int, float, string);
        static assert(isIntOrFloat!(Tup[0]));  // int is an int or a float
        static assert(isIntOrFloat!(Tup[1]));  // float is an int or a float
        static assert(!isIntOrFloat!(Tup[2])); // string is neither an int nor a float
    }
    

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

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

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

    Limitations:

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

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

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

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

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

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

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

    class Server
    {
        this() { }
        void run() { }
    }
    
    void main()
    {
        new Server.run();    // error
        new Server().run();  // ok
    }
    
  4. Implicit Function Template Instantiation now supports enclosing type/scope deduction:
  5. 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
    }
    
  6. DDoc can now warn the user when the symbol names in a ddoc comment do not match the actual code:
  7. 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.

  8. Strings literals which are sliced are now implicitly convertible to a char pointer:
  9. 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
    }
    
  10. Templated and non-template functions can now be overloaded against each other:
  11. 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);
    }
    
  12. Cross-module template declarations can now make an overload set:
  13. 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:
  2. 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:
  2. 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.

  3. Introduced the getVirtualIndex trait to get the index of a virtual function:
  4. 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]));
    }
    
  5. Introduced the isOverrideFunction trait which indicates whether or not a function is overriding:
  6. 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:
  2. 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();
    }
    
  3. std.conv.to and std.string.format are now pure functions:
  4. 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);
    }
    
  5. Introduced generic strip/stripLeft/stripRight functions:
  6. 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);
    }
    
  7. Introduced an overload of std.string.translate which can take a buffer, avoiding the need for implicit memory allocations:
  8. 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");
    }
    
  9. Introduced the thisExePath function to retrieve the executable path of the currently running process:
  10. 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());
    }
    
  11. New API for std.regex match/replace functions:
  12. 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.

  13. Compile-time std.regex.ctRegex now supports lookaround just like run-time one:
  14. Now ctRegex supports full syntax spectrum of run-time one except for set algebra inside of a character class. For instance, the following now compiles and passes:

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

List of all bug fixes and enhancements in D 2.064:

DMD Compiler regressions

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

DMD Compiler bugs

  1. Bugzilla 952: Strange "Error:" prefix on some warning messages
  2. Bugzilla 1982: [CTFE] Problems with compile-time null
  3. Bugzilla 2407: function pointer as an enum's base type doesn't work
  4. Bugzilla 2486: taking address of slice rvalue should not be allowed
  5. Bugzilla 3096: EnumBaseType
  6. Bugzilla 3646: Default values of function arguments are ignored when instantiating a template.
  7. Bugzilla 3866: anonymous delegate with default parameters cross-talks to another anonymous delegate
  8. Bugzilla 4018: __FILE__ and __LINE__ as default template parameters not set to instantiation point per spec
  9. Bugzilla 4481: ICE(glue.c,!vthis->csym) or compiles, depending on the import statements order
  10. Bugzilla 4611: stack overflow or ICE(cgcod.c) when static array of structs exceeds 16MB limit
  11. Bugzilla 4841: -inline wrecks certain nested structs causing error "*** is a nested function and cannot be accessed from ***"
  12. Bugzilla 4899: Ddoc: Warnings about stray parens do not include file and line numbers for module comments
  13. Bugzilla 5012: ICE(cod3.c): handling a nested function in inline asm.
  14. Bugzilla 5655: Lambda inside static foreach saves wrong value of counter
  15. Bugzilla 5842: hash table corruption
  16. Bugzilla 5911: Closure destroys the thrown Exception .
  17. Bugzilla 5988: Template accepts instantiating an already-instantiated template type
  18. Bugzilla 6107: ICE(expression.c) when a non-template member named '__ctor' exists in a struct, and the constructor is attempted to be invoked.
  19. Bugzilla 6169: [CTFE] pure functions cannot compute constants using functions not marked as pure
  20. Bugzilla 6178: Struct inside the AA are not init correctly
  21. Bugzilla 6310: Missing "template instantiation" traceback when an error happens in the template parameter of an alias.
  22. Bugzilla 6461: multiple definitions with typeid and multiobj
  23. Bugzilla 6711: "with" doesn't work with "alias this"
  24. Bugzilla 6720: ICE(cod1.c) casting return of void function to bool
  25. Bugzilla 6799: ICE(type.c) involving AAs and pointers to structs
  26. Bugzilla 6906: Cannot assign value into associative array if contains opAssign
  27. Bugzilla 7051: Class member with un-@safe destructor gives confusing error
  28. Bugzilla 7156: ICE(go.c): with 199 or 200 repeated integer increments, only with -O
  29. Bugzilla 7202: Hole in type system still present for delegates
  30. Bugzilla 7254: ICE(cod3.c) returning strings as static arrays
  31. Bugzilla 7436: ICE(cg87.c) ubyte = ubyte op= float
  32. Bugzilla 7474: ICE(cgcs.c) on instantiating a struct with field and destructor as tuple
  33. Bugzilla 7522: ICE(interpret.c) Accessing a non-static member without this
  34. Bugzilla 7524: D1: #line __LINE__ doesn't parse
  35. Bugzilla 7533: Error with no line number with pure static ctor
  36. Bugzilla 7538: All kinds of property functions should be called before getting their types inside typeof
  37. Bugzilla 7565: ICE(cg87):202, postincrement of a double parameter, 64-bit only
  38. Bugzilla 7656: ddoc misinterprets commented parentheses in an example
  39. Bugzilla 7715: DDoc eats , , etc. inside d_code section
  40. Bugzilla 7727: "static initializer" for non-static unions too
  41. Bugzilla 7746: Error with 'TOK232' declaring enum of anonymous nested class type
  42. Bugzilla 7780: Template mixin'd members do not properly overload
  43. Bugzilla 7806: ICE(gloop.c) iterating with idouble, when compiling with -O
  44. Bugzilla 7848: pure and nothrow ignored on unittest blocks
  45. Bugzilla 7892: Compiler-generated struct copies can result in errors when ctor is @disable'd
  46. Bugzilla 7976: ICE(backend/cg87.c)assignment btw two elements of dynamic array of complex number types
  47. Bugzilla 7988: [CTFE] CTFE return values should be allowed in compile-time expressions
  48. Bugzilla 8119: Cannot cast from void* to forwarded struct pointer
  49. Bugzilla 8179: ICE(e2ir.c) with failed fixed size array cast
  50. Bugzilla 8253: CTFE ICE: calling of member function of non-CTFE class variable
  51. Bugzilla 8285: Issue with slice returned from CTFE function
  52. Bugzilla 8352: Wrong "__overloadset isn't a template" error
  53. Bugzilla 8360: Destruction of uninitialized temporary struct with assert
  54. Bugzilla 8361: [ICE] (eh.c line 316) with struct with dtor in assert
  55. Bugzilla 8441: mixin containing template functions causes compiler errors
  56. Bugzilla 8563: Exception segfault
  57. Bugzilla 8579: Default parameter appears a part of typeof().stringof of a function variable
  58. Bugzilla 8651: Slice op Slice throws exceptions (not errors), and nothrow
  59. Bugzilla 8733: Normalize -of path on Windows
  60. Bugzilla 8795: mixing in "switch" or "interface;" makes dmd segfault
  61. Bugzilla 8911: -property makes fullyQualifiedName fail for functions
  62. Bugzilla 8956: Ability to break typesystem with constructor/postblit/destructor (e.g. modify immutable)
  63. Bugzilla 8977: Ability to break typesystem with static struct initializer (e.g. modify immutable)
  64. Bugzilla 9017: __traits(compiles, { enum e = ; }) 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
Version D 2.063 May 28, 2013

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.

List of all bug fixes and enhancements in D 2.063.

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

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

  15. 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)'
    
  16. 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
    
  17. 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.

Compiler Enhancements

  1. Added -main switch which adds an empty main function:

    The -main switch is primarily useful when unittesting libraries:

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

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

    $ dmd -unittest -main -run test.d
    
  2. Added -cov=percentage switch for minimal coverage tests.

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

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

    Example of coverage testing:

    $ dmd -cov=90 test.d
    $ test
    Error: test.d is 80% covered, less than required 90%
    
  3. Added ability to override the mangling of a symbol with a compiler pragma:

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

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

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

Phobos Changes

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

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

    class A
    {
        this() {}
        this(int) {}
    }
    
    class B
    {
        // ReturnType!(scoped!A) a;  // disallowed in 2.063
        typeof(scoped!A()) a;        // rewritten, compiles in 2.063
    
        this()
        {
            a = scoped!A(1);  // would not compile in 2.062, but works with syntax used for 2.063
        }
    }
    

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

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

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

Phobos Enhancements

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

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

  2. std.getopt can now set booleans to false:

    Example code:

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

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

  3. Added ownerTid property in std.concurrency:

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

    void fun()
    {
        string res = receiveOnly!string();
        assert(res == "Main calling");
    
        ownerTid.send("Child responding");  // new
    }
    
    void main()
    {
        auto child = spawn(&fun);
        child.send("Main calling");
    
        string res = receiveOnly!string();
        assert(res == "Child responding");
    }
    

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


List of all bug fixes and enhancements in D 2.063:

DMD Compiler regressions

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

DMD Compiler bugs

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

DMD Compiler enhancements

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

Phobos regressions

  1. Bugzilla 9122: std.concurrency send() fails with multiple arrays
  2. Bugzilla 9742: std.math.floor returns 0 for any value x > -1 and x < 0
  3. Bugzilla 10122: `Appender` doesn't work with disabled default construction

Phobos bugs

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

Phobos enhancements

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

Druntime bugs

  1. Bugzilla 4307: spawn()'ed thread doesn't terminate
  2. Bugzilla 6024: Document that Windows 2000 SP4 is no longer supported
  3. Bugzilla 10057: [2.063 beta] Module info overwritten in shared phobos.
  4. Bugzilla 10081: Incorrect char array comparison

Optlink bugs

  1. Bugzilla 6144: Unexpected OPTLINK Termination at EIP=00428DA3

Installer bugs

  1. Bugzilla 9343: Problem installing dmd-2.061-0.fedora.x86_64.rpm on Fedora 18

Website bugs

  1. Bugzilla 4847: std.algorithm.topN documentation
  2. Bugzilla 9544: D logo image is broken on non-root-level pages
  3. Bugzilla 9609: Ddoc tags for std.string.icmp seem wrong
  4. Bugzilla 10036: missing core.atomic docs on dlang.org
Version D 2.062 Feb 18, 2013

Language Changes

  1. typeof() change:
  2. As a result of fixing Bugzilla 6408, the usage of typeof() and indexing may require changes to user code:

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

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

    import std.range;
    
    template ElementTypeOf(T)
    {
        // use T.init
        alias typeof(T.init[0]) ElementTypeOf;
    }
    
    void main()
    {
        // use std.range.ElementType
        static assert(is(ElementType!(int[]) == int));
    
        // use custom template after fixing its code
        static assert(is(ElementTypeOf!(int[]) == int));
    }
    
  3. alias syntax change:
  4. The newly introduced "alias foo = int" syntax is not usable with subtyping. This is to prevent confusion from a possible future syntax which would enable aliasing of super constructors. For now, the existing alias syntax can be used:

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

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

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

List of all bug fixes and enhancements:

DMD Compiler regressions

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

DMD Compiler bugs

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

DMD Compiler enhancements

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

Phobos regressions

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

Phobos bugs

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

Phobos enhancements

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

Druntime bugs

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

Website regressions

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

Website bugs

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

Website enhancements

  1. Bugzilla 9302: Document extern properly
Version D 2.061 Jan 1, 2013

New/Changed Features

Bugs Fixed

Version D 2.060 Aug 2, 2012

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

Version D 2.059 Apr 12, 2012

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

Version D 2.058 Feb 14, 2012

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

Version D 2.057 Dec 13, 2011

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

Version D 2.056 Oct 26, 2011

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

Version D 2.055 Sep 4, 2011

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

Version D 2.054 Jul 10, 2011

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

Version D 2.053 May 12, 2011

New/Changed Features

Druntime Bugs Fixed

Library Bugs Fixed

DMD Bugs Fixed

Version D 2.052 Feb 17, 2011

New/Changed Features

Bugs Fixed

Version D 2.051 Dec 21, 2010

New/Changed Features

Bugs Fixed

Version D 2.050 Oct 29, 2010

New/Changed Features

Bugs Fixed

Version D 2.049 Sep 13, 2010

New/Changed Features

Bugs Fixed

Version D 2.048 Aug 8, 2010

New/Changed Features

Bugs Fixed

Version D 2.047 Jun 11, 2010

New/Changed Features

Bugs Fixed

Version D 2.046 May 10, 2010

New/Changed Features

Bugs Fixed

Version D 2.045 May 4, 2010

New/Changed Features

Bugs Fixed

Version D 2.044 Apr 30, 2010

New/Changed Features

Bugs Fixed

Version D 2.043 Apr 6, 2010

New/Changed Features

Bugs Fixed

Version D 2.042 Mar 19, 2010

New/Changed Features

Bugs Fixed

Version D 2.041 Mar 7, 2010

New/Changed Features

Bugs Fixed

Version D 2.040 Jan 29, 2010

New/Changed Features

Bugs Fixed

Version D 2.039 Jan 1, 2010

New/Changed Features

Bugs Fixed

Version D 2.038 Dec 30, 2009

New/Changed Features

Bugs Fixed

Version D 2.037 Dec 3, 2009

New/Changed Features

Bugs Fixed

Version D 2.036 Nov 5, 2009

New/Changed Features

Bugs Fixed

Version D 2.035 Oct 14, 2009

New/Changed Features

Bugs Fixed

Version D 2.034 Oct 11, 2009

New/Changed Features

Bugs Fixed

Version D 2.033 Oct 5, 2009

New/Changed Features

Bugs Fixed

Version D 2.032 Sep 2, 2009

New/Changed Features

Bugs Fixed

Version D 2.031 July 6, 2009

New/Changed Features

Bugs Fixed

Version D 2.030 May 11, 2009

New/Changed Features

Bugs Fixed

Version D 2.029 Apr 19, 2009

New/Changed Phobos

New/Changed Features

Bugs Fixed

Version D 2.028 Apr 7, 2009

New/Changed Features

Bugs Fixed

Version D 2.027 Mar 31, 2009

New/Changed Features

Bugs Fixed

Version D 2.026 Mar 3, 2009

New/Changed Features

Bugs Fixed

Version D 2.025 Feb 14, 2009

New/Changed Features

Bugs Fixed

Version D 2.023 Jan 2, 2009

New/Changed Features

Bugs Fixed

Version D 2.022 Dec 11, 2008

New/Changed Features

Bugs Fixed

Version D 2.021 Nov 25, 2008

New/Changed Features

Bugs Fixed

Version D 2.020 Oct 20, 2008

New/Changed Features

Bugs Fixed

Version D 2.019 Sep 2, 2008

New/Changed Features

Bugs Fixed

Version D 2.018 Aug 7, 2008

New/Changed Features

Bugs Fixed

Version D 2.017 Jul 11, 2008

New/Changed Features

Bugs Fixed

Version D 2.016 Jul 8, 2008

New/Changed Features

Bugs Fixed

Version D 2.015 Jun 17, 2008

New/Changed Features

Bugs Fixed

Version D 2.014 May 16, 2008

New/Changed Features

Bugs Fixed

Version D 2.013 Apr 22, 2008

New/Changed Features

Bugs Fixed

Version D 2.012 Mar 6, 2008

New/Changed Features

Bugs Fixed

Version D 2.011 Feb 18, 2008

New/Changed Features

Bugs Fixed

Version D 2.010 Jan 20, 2008

New/Changed Features

Bugs Fixed

Version D 2.009 Jan 1, 2008

New/Changed Features

Bugs Fixed

Version D 2.008 Nov 27, 2007

New/Changed Features

Bugs Fixed

Version D 2.007 Oct 31, 2007

New/Changed Features

Bugs Fixed

Version D 2.006 Oct 16, 2007

New/Changed Features

Bugs Fixed

Version D 2.005 Oct 1, 2007

New/Changed Features

Bugs Fixed

Version D 2.004 Sep 5, 2007

New/Changed Features

Bugs Fixed

Version D 2.003 Jul 21, 2007

New/Changed Features

Bugs Fixed

Version D 2.002 Jul 1, 2007

New/Changed Features

Bugs Fixed

Version D 2.001 Jun 27, 2007

New/Changed Features

Bugs Fixed

Version D 2.000 Jun 17, 2007

New/Changed Features

Bugs Fixed

)
Forums | Comments | Search | Downloads | Home