Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

Change Log: 2.100.0

previous version: 2.099.1

Download D 2.100.0
released May 10, 2022

2.100.0 comes with 22 major changes and 179 fixed Bugzilla issues. A huge thanks goes to the 41 contributors who made 2.100.0 possible.

List of all bug fixes and enhancements in D 2.100.0.

Compiler changes

  1. End deprecation period for using alias this for partial assignment.

    Starting with this release, alias this may not be used for the partial assignment of a left-hand side operand. Any such assignment will result in a compiler error.

    If a struct has a single member which is aliased this directly or aliased to a ref getter function that returns the mentioned member, then alias this may be used since the object will be fully initialised.

    struct Allowed
    {
        int onemember;
        alias onemember this;
    }
    
    struct Rejected
    {
        int aliased;
        long other;
        alias aliased this;
    }
    
    void fun(Allowed a, Rejected r)
    {
        a = 0; // OK, struct has only one member.
        r = 0; // Error, cannot use `alias this` to partially initialize variable `r` of type `Rejected`. Use `r.aliased`
    }
    
  2. The deprecation period for D1-style operators has ended.

    Starting with this release, any use of the deprecated D1 overload operators will result in a compiler error.

    The corrective action is to replace all operators with their D2 equivalent.

    The following D1 operator overloads have been removed in favor of opUnary:

    • opNeg must be replaced with opUnary(string op)() if (op == "-")
    • opCom must be replaced with opUnary(string op)() if (op == "~")
    • opPostIncmust be replaced with opUnary(string op)() if (op == "++")
    • opPostDecmust be replaced with opUnary(string op)() if (op == "--")
    • opStarmust be replaced with opUnary(string op)() if (op == "*")

    The following D1 operator overloads have been removed in favor of opBinary:

    • opAdd must be replaced with opBinary(string op)(...) if (op == "+")
    • opSub must be replaced with opBinary(string op)(...) if (op == "-")
    • opMul must be replaced with opBinary(string op)(...) if (op == "*")
    • opDiv must be replaced with opBinary(string op)(...) if (op == "/")
    • opMod must be replaced with opBinary(string op)(...) if (op == "%")
    • opAnd must be replaced with opBinary(string op)(...) if (op == "&")
    • opXor must be replaced with opBinary(string op)(...) if (op == "^")
    • opOr must be replaced with opBinary(string op)(...) if (op == "|")
    • opShl must be replaced with opBinary(string op)(...) if (op == "<<")
    • opShr must be replaced with opBinary(string op)(...) if (op == ">>")
    • opUShr must be replaced with opBinary(string op)(...) if (op == ">>>")
    • opCat must be replaced with opBinary(string op)(...) if (op == "~")
    • opIn must be replaced with opBinary(string op)(...) if (op == "in")

    The following D1 operator overloads have been removed in favor of opBinaryRight:

    • opAdd_r must be replaced with opBinaryRight(string op)(...) if (op == "+")
    • opSub_r must be replaced with opBinaryRight(string op)(...) if (op == "-")
    • opMul_r must be replaced with opBinaryRight(string op)(...) if (op == "*")
    • opDiv_r must be replaced with opBinaryRight(string op)(...) if (op == "/")
    • opMod_r must be replaced with opBinaryRight(string op)(...) if (op == "%")
    • opAnd_r must be replaced with opBinaryRight(string op)(...) if (op == "&")
    • opXor_r must be replaced with opBinaryRight(string op)(...) if (op == "^")
    • opOr_r must be replaced with opBinaryRight(string op)(...) if (op == "|")
    • opShl_r must be replaced with opBinaryRight(string op)(...) if (op == "<<")
    • opShr_r must be replaced with opBinaryRight(string op)(...) if (op == ">>")
    • opUShr_r must be replaced with opBinaryRight(string op)(...) if (op == ">>>")
    • opCat_r must be replaced with opBinaryRight(string op)(...) if (op == "~")
    • opIn_r must be replaced with opBinaryRight(string op)(...) if (op == "in")

    Note: The opBinaryRight overload operator takes precedence over any opBinary operators.

    The following D1 operator overloads have been removed in favor of opOpAssign:

    • opAddAssign must be replaced with opOpAssign(string op)(...) if (op == "+")
    • opSubAssign must be replaced with opOpAssign(string op)(...) if (op == "-")
    • opMulAssign must be replaced with opOpAssign(string op)(...) if (op == "*")
    • opDivAssign must be replaced with opOpAssign(string op)(...) if (op == "/")
    • opModAssign must be replaced with opOpAssign(string op)(...) if (op == "%")
    • opAndAssign must be replaced with opOpAssign(string op)(...) if (op == "&")
    • opOrAssign must be replaced with opOpAssign(string op)(...) if (op == "|")
    • opXorAssign must be replaced with opOpAssign(string op)(...) if (op == "^")
    • opShlAssign must be replaced with opOpAssign(string op)(...) if (op == "<<")
    • opShrAssign must be replaced with opOpAssign(string op)(...) if (op == ">>")
    • opUShrAssign must be replaced with opOpAssign(string op)(...) if (op == ">>>")
    • opCatAssign must be replaced with opOpAssign(string op)(...) if (op == "~")

    The following D1 operator overloads have been removed in favor of alias this:

    • opDot must be replaced with alias this

  3. scope as a type constraint on class, struct, and enum declarations is deprecated.

    scope as a type constraint on class declarations was meant to force users of a class to scope allocate it, which resulted in the class being placed on the stack rather than GC-allocated. While it has been scheduled for deprecation for quite some time, the compiler will emit a deprecation warning on usage starting from this release.

    scope as a type constraint on struct or enum declarations has never had any effect, and has been deprecated as well.

    scope class C { }  // Deprecation: `scope` as a type constraint is deprecated. Use `scope` at the usage site.
    scope struct S { } // Ditto
    scope enum E { }   // Ditto
    

    Using scope to stack-allocate class is still suported, only the type constraint is deprecated.

    class C { }
    
    void main () @nogc
    {
        scope c = new C;
    }
    
  4. The deprecation period of unannotated asm blocks has been ended.

    See the Deprecated Features for more information.

    Starting with this release, using asm blocks will assume to be @system, @nogc, impure and might throw, unless explicitly annotated.

  5. The deprecation period of the delete keyword has been ended.

    See the Deprecated Features for more information.

    Starting with this release, using the delete keyword will result in a compiler error.

    As a replacement, users are encouraged to use destroy if feasible, or core.memory.__delete as a last resort.

  6. Improvements for the C++ header generation

    The following features/bugfixes/improvements were implemented for the experimental C++ header generator:

    • The implicitly generated context pointer for nested aggregates is now emitted as outer instead of this
    • Explicit mangling via pragma(mangle, "...") is partially supported for functions / variables. The mangling is used as the identifier of extern(C) declarations because C doesn't mangle declaration names. extern(C++) declarations are ignored because there's no portable alternative for C++.
    • Emits destructors not easily accessible from C++ (e.g. extern(D)) as private members, preventing the creation of instances that would not be destroyed on the C++ side.
    • No longer generates extern(C) functions in aggregates that are emitted with D mangling.

    Note: The header generator is still considered experimental, so please submit any bugs encountered to the bug tracker.

  7. The deprecation period for scope as a type constraint on interface declarations has ended.

    Starting with this release, using scope as a type constraint on interface declarations will result in a compiler error.

    scope interface I { }  // Error: `scope` as a type constraint is obsolete.  Use `scope` at the usage site.
    
  8. The inout attribute no longer implies the return attribute

    The compiler would formerly add the return attribute to inout functions, under the assumption that every inout function would return its argument. However, it could also return a member of the inout argument, which would still be inout because const and immutable are transitive, while return semantics are not transitive.

    @safe:
    
    struct Node
    {
        Node* next;
        int x;
    
        // This escapes a pointer to this struct
        // This used to be allowed because of `inout`
        @safe inout(int)* getScopePointer() inout
        {
            return &this.x;
        }
    
        // But what if you do not return a pointer to this struct?
        // `inout` applies because it's transitive, but `return ref` does not
        // The compiler could needlessly treat the returned pointer as a scope pointer
        @safe inout(int)* getNonScopePointer() inout
        {
            return &this.next.x;
        }
    
        // Corrective action for the first case:
        // if you want `inout` + `return ref`, annotate it with both
        @safe inout(int)* getScopePointer() inout return
        {
            return &this.x;
        }
    }
    
  9. Support contract invariant version identifier.

    Sometimes it is useful to compile code only when invariants are enabled. This feature provides the reserved version identifier D_Invariants which evaluates to true or false when invariants are compiled in or not respectively.

    bool hit;
    
    class Foo
    {
        this() {}
        invariant { hit = true; }
    }
    
    void main()
    {
        cast(void) new Foo();
    
        version(D_Invariants) assert(hit); // runs if invariants are compiled in
    }
    
  10. Implement DIP 1038: @mustuse

    @mustuse is a new attribute that can be applied to a struct or union type to make ignoring an expression of that type into a compile-time error. It can be used to implement alternative error-handling mechanisms for code that cannot use exceptions, including @nogc and BetterC code.

    For more information, see DIP 1038.

  11. Added .tupleof property for static arrays

    The .tupleof property may now be used with instances of static arrays, yielding an lvalue sequence of each element in the array.

    Note that this is only for static array instances. It remains an error when used on a type, to avoid breaking older code lacking suitable checks. As a workaround, use typeof((T[N]).init.tupleof).

    void foo(int, int, int) { /* ... */ }
    
    int[3] ia = [1, 2, 3];
    foo(ia.tupleof); // same as `foo(1, 2, 3);`
    
    float[3] fa;
    //fa = ia; // error
    fa.tupleof = ia.tupleof;
    assert(fa == [1F, 2F, 3F]);
    
  12. Usage of this and super as types has been removed

    Prior to this release, using this or super as a type resulted in a compiler error suggesting to use typeof(this) or typeof(super) instead. This has now been completely removed from the language, and the parser won't recognize this wrong code anymore.

  13. A missed case of switch case fallthrough has been deprecated

    Forgetting a break; statement in a switch case has been turned from a deprecation into an error in DMD 2.099.0. However, the compiler would not issue an error when using multiple values in a single case statement:

    void main()
    {
        int i = 0;
        switch (10)
        {
            case 10, 11:
                i = 4;
                // accidental falltrough allowed
            default:
                i = 8;
        }
        assert(i == 4); // fails
    }
    

    This bug has been fixed, but to avoid breaking code, this specific case now issues a deprecation warning. Starting from DMD 2.110, it will produce an error just like other cases of switch case fallthrough.

Library changes

  1. New function bind in std.functional

    It is used to pass the fields of a struct as arguments to a function. For example, it can be used in a range pipeline to give names to the elements of a std.typecons.Tuple:

    import std.stdio;
    import std.range;
    import std.algorithm;
    import std.functional;
    
    void printWithLineNumbers(File f)
    {
        f.byLine
            .enumerate
            .each!(bind!((num, line) {
                writefln("%8d %s", num, line);
            }));
    }
    

    See the standard library documentation for more information.

  2. Nullable in std.typecons can now act as a range

    Nullable now offers an alternative 0 or 1 element range interface.

    import std.stdio;
    import std.algorithm;
    import std.typecons;
    
    void printValues(Nullable!int[] values)
    {
        values.joiner.each!writeln();
    }
    
  3. Zlib updated to 1.2.12

    The bundled zlib has been updated to version 1.2.12.

Tools changes

  1. rdmd now supports specifying the D compiler using the RDMD_DMD environment variable

    rdmd now uses the RDMD_DMD environment variable, if it is present in the environment, to choose the D compiler to use. As with the --compiler option, the variable's value must specify the name or path of a compiler with a DMD-like command line syntax, such as gdmd or ldmd2. The variable overrides the default (which is decided at the time rdmd was built), but can still be overridden by the --compiler option.

Dub changes

  1. Builds dynamicLibrary targets as dynamic libraries instead of static libraries.

    Dub will no longer build dynamicLibrary targetType's as staticLibrary.

    Except for x86_omf. This has been disabled due to numerous issues that will lead this to not doing what is expected of it.

    No compiler or linker flags have been added at this time, you will need to specify the relevant flag to get the compiler to link dynamically against Phobos.

  2. The $DUB_BUILD_PATH variable was added

    The $DUB_BUILD_PATH variable is now defined inside the postBuildCommands section. It contains the absolute path in which the package was built, and can be used to copy by-products of the build process to their intended locations.

    For example, if an executable exports symbols, you will want to make the resulting import library and symbols export file available somewhere. That can be done with a dub.json section like this:

        "postBuildCommands-windows": [
            "copy /y $DUB_BUILD_PATH\\$DUB_TARGET_NAME.lib $PACKAGE_DIR\\lib"
            "copy /y $DUB_BUILD_PATH\\$DUB_TARGET_NAME.exp $PACKAGE_DIR\\lib"
        ],
    
  3. Command environment variable substitution changed

    Now users can use the documented predefined variables inside custom command directives without the need for a wrapper shell script.

    Before this would have failed:

    "preBuildCommands": ["$DC -run foo.d"]
    

    unless DC was defined as environment variable outside DUB.

    It was before possible to run a script that used the $DC environment variable or on POSIX escape the $ with $$DC to make the shell substitute the variable. These workarounds are no longer needed now.

    API change: none of the different command directives are no longer substituted with the process environment variables. You now access the raw commands as provided by the user in the recipe. dub describe has been adjusted and now also processes the predefined environment variables as well as the process environment variables.

  4. Posix: use /etc/dub/settings.json if DUB is installed in /usr

    For Linux distributions that put the dub installation in /usr, there is now a special case that DUB will load from /etc/dub/settings.json (absolute path) if the installation is inside /usr.

    Previously settings would have attempted to be loaded from /usr/etc/dub/settings.json if installed in /usr/bin/dub. This is still loaded if it exists, but if not /etc/dub/settings.json will be loaded.

  5. Adds injection of source files from dependencies via injectSourceFiles command

    Each (sub)package now supports a source file that will be included in any executable or dynamic library that depends either directly or indirectly on it.

    This can be used to register and unregister elements of a package within the dependant package without requiring the dependant to acknowledge that the registration mechanism needs to take place.

    A comparable existing feature to this is the usage of sourceLibrary target type. A sourceLibrary targetType defers compilation of source code until it is dependent upon by a static library, dynamic library or executable (sub)package. Unlike sourceLibrary the injection of source code using this feature will inject it into every dynamic library and executable that depends on it, regardless of how deep it is in the dependency graph.


List of all bug fixes and enhancements in D 2.100.0:

DMD Compiler regression fixes

  1. Bugzilla 22788: [REG master] Expression header out of sync
  2. Bugzilla 22797: [REG master] Internal Compiler Error: cannot mixin static assert ''
  3. Bugzilla 22801: [REG 2.099.0-beta.1] Can't return address of return ref parameter from constructor
  4. Bugzilla 22810: [REG 2.088] FAIL: runnable/test15.d on BigEndian targets
  5. Bugzilla 22833: [REG 2.083] error: 'string' is not a member of 'std'
  6. Bugzilla 22844: [REG 2.089] SIGBUS, Bus error in _d_newitemU
  7. Bugzilla 22881: ICE Index of array outside of bounds at CTFE
  8. Bugzilla 22913: importC: array index expression parsed as cast
  9. Bugzilla 22961: importC: K&R-style main function rejected
  10. Bugzilla 22997: DMD crash: copy ctor can't call other ctor
  11. Bugzilla 22999: no switch fallthrough error with multi-valued case
  12. Bugzilla 23019: Missing filename when -of points to an existing directory
  13. Bugzilla 23036: Rvalue constructor with default parameter crashes compiler in the presence of a copy constructor
  14. Bugzilla 23046: [REG][CODEGEN] __simd(XMM.LODLPS) bad codegen
  15. Bugzilla 23087: getLinkage trait regression for overloads with v2.100.0-rc.1
  16. Bugzilla 23089: Linkage-related ICE regression in v2.100.0-rc.1
  17. Bugzilla 23097: [REG 2.100] ArrayIndexError@src/dmd/mtype.d(4767): index [18446744073709551615] is out of bounds for array of length 0
  18. Bugzilla 23098: array literal to scope inout parameter not allowed in safe code

DMD Compiler bug fixes

  1. Bugzilla 7625: inlining only works with explicit else branch
  2. Bugzilla 12344: .di generation doesn't include contracts in interfaces
  3. Bugzilla 19948: Fully qualified name not used in errors when implicit const conversion is involved
  4. Bugzilla 20149: [DIP1000] Local data escapes inout method if not decorated with return
  5. Bugzilla 20603: 'cannot use non-constant CTFE pointer in an initializer' in recursive structure with overlap
  6. Bugzilla 20881: [DIP1000] scope inference turns return-ref into return-scope
  7. Bugzilla 21008: dmd segfaults because of __traits(getMember, ...) and virtual function overriding
  8. Bugzilla 21324: @live not detecting overwrite of Owner without disposing of previous owned value
  9. Bugzilla 21546: covariant return checks for functions wrong if returning by ref
  10. Bugzilla 21676: [ICE][SIMD] DMD crashing with SIMD + optimizations + inlining
  11. Bugzilla 21975: is expression ignores implicit conversion of struct via alias this when pattern matching
  12. Bugzilla 22023: adding return to escaped argument of a variadic defeats @safe
  13. Bugzilla 22145: scope for foreach parameters is ignored
  14. Bugzilla 22202: Wrong error message for implicit call to @system copy constructor in @safe code
  15. Bugzilla 22221: [dip1000] pure function can escape parameters through Exception
  16. Bugzilla 22234: __traits(getLinkage) returns wrong value for extern(System) functions
  17. Bugzilla 22489: C header generation ignores custom mangling
  18. Bugzilla 22539: [dip1000] slicing of returned ref scope static array should not be allowed
  19. Bugzilla 22635: opCast prevent calling destructor for const this.
  20. Bugzilla 22751: DMD as a library crashes with fatal() on parseModule
  21. Bugzilla 22755: ImportC: declared symbol must be available in initializer
  22. Bugzilla 22756: ImportC: no __builtin_offsetof
  23. Bugzilla 22776: string literal printing fails on non-ASCII/non-printable chars
  24. Bugzilla 22782: [dip1000] address of ref can be assigned to non-scope parameter
  25. Bugzilla 22793: importC: __import conflicts when importing multiple modules with same package
  26. Bugzilla 22802: [dip1000] First ref parameter seen as return destination even with this
  27. Bugzilla 22806: cppmangle: Complex real mangled incorrectly
  28. Bugzilla 22807: ImportC: Array index is out of bounds for old-style flexible arrays.
  29. Bugzilla 22808: ImportC: function not decaying to pointer to function in return statement.
  30. Bugzilla 22809: ImportC: druntime’s definition of __builtin_offsetof leads to dereference of invalid pointer.
  31. Bugzilla 22812: ImportC: C11 does not allow newlines between the start and end of a directive
  32. Bugzilla 22818: typesafe variadic function parameter of type class should be scope
  33. Bugzilla 22823: dmd.root.file: File.read fails to read any file on PPC
  34. Bugzilla 22830: Solaris: error: module 'core.stdc.math' import 'signbit' not found
  35. Bugzilla 22831: No error for malformed extern(C) main function
  36. Bugzilla 22837: [dip1000] checkConstructorEscape quits after first non-pointer
  37. Bugzilla 22840: [dip1000] inout method with inferred @safe escapes local data
  38. Bugzilla 22841: importC: Error: variable 'var' is shadowing variable 'var'
  39. Bugzilla 22842: importC: cannot declare function with a typedef
  40. Bugzilla 22845: DWARF .debug_line section is not standard compliant
  41. Bugzilla 22846: [REG 2.066] SIGBUS, Bus error in _d_newarrayiT
  42. Bugzilla 22848: DWARF .debug_line section should be generated to conform with DW_AT_stmt_list bounds
  43. Bugzilla 22874: ICE: Segmentation fault building druntime on mips64el-linux
  44. Bugzilla 22876: importC: expression parsing affected by parentheses that should do nothing
  45. Bugzilla 22878: importC: glibc fallback for HUGE_VAL gives 'not representable'
  46. Bugzilla 22884: ImportC: function does not decay to pointer when being cast
  47. Bugzilla 22885: ImportC: typedef declared with itself should work
  48. Bugzilla 22886: ImportC: forward declaration of struct in a function prototype leads to redeclaration with different type error
  49. Bugzilla 22887: ImportC: typedef enum fails
  50. Bugzilla 22892: importC: dereferencing array as pointer is not supported
  51. Bugzilla 22894: importC: static struct initializer can't take address of own field
  52. Bugzilla 22895: importC: exponent parsed as member access
  53. Bugzilla 22896: importC: 'function redeclaration with different type' should ignore const
  54. Bugzilla 22897: importC: segfault calling forward-declared static function through pointer
  55. Bugzilla 22899: importC: extra parentheses in sizeof should give error with typedef types
  56. Bugzilla 22904: importC: syntax error for function call with casted result and parentheses around name
  57. Bugzilla 22906: DMD as a library hangs on semantic analysis of non regular D files
  58. Bugzilla 22909: importC: u8 strings rejected by parser
  59. Bugzilla 22910: [dip1000] return scope struct member functions allow returning this by ref
  60. Bugzilla 22912: importC: syntax error for function call with cast and typedef and parentheses around name
  61. Bugzilla 22914: outdated supplemental error "perhaps remove scope"
  62. Bugzilla 22915: Errors for invalid foreach aggregates should print the type
  63. Bugzilla 22918: importC: some types not zero-initialized in static variables
  64. Bugzilla 22919: [dip1000] -checkaction=context gives "assigned to __assertOp2 with longer lifetime"
  65. Bugzilla 22923: importC: forward-declared static variable has invalid address
  66. Bugzilla 22924: importC: boolean expression result should be int
  67. Bugzilla 22927: importC: 'struct already exists' with forward reference and function with same name
  68. Bugzilla 22928: importC: array does not have a boolean value
  69. Bugzilla 22929: importC: extern array with unknown length gives bounds errors
  70. Bugzilla 22930: importC: switch statement should use default:break; if no default specified
  71. Bugzilla 22931: importC: Error: 0 has no effect
  72. Bugzilla 22933: importC: goto skips declaration of variable
  73. Bugzilla 22934: Header generator emits context pointer as this
  74. Bugzilla 22935: importC: offsetof with array element gives 'dereference of invalid pointer'
  75. Bugzilla 22951: Dtor missing from generated C++ header
  76. Bugzilla 22954: Header generator emits extern(C) member functions
  77. Bugzilla 22955: importC: wrong alignof for D struct with specified alignment
  78. Bugzilla 22970: importC: taking address one past array end gives bounds error
  79. Bugzilla 22971: importC: can't initialize unsigned char array with string literal
  80. Bugzilla 22972: importC: static variable cannot be read at compile time
  81. Bugzilla 22974: importC: D name mangling applied to extern variable inside function
  82. Bugzilla 22976: importC: fails to multiply by element size when doing address-of
  83. Bugzilla 22988: no short-circuiting when constant folding ternary operator
  84. Bugzilla 22994: importC: some types not zero-initialized in static array
  85. Bugzilla 23000: final switch error has no line number with -checkaction=C
  86. Bugzilla 23002: importC: struct or union field with same name as type gives circular reference error
  87. Bugzilla 23003: ImportC should not import object.d
  88. Bugzilla 23004: importC: calling function pointer named 'init' or 'stringof' from struct or union pointer gives error
  89. Bugzilla 23008: importC: dmd asserts on empty struct or union as global
  90. Bugzilla 23009: [CODEGEN][SIMD] SIMD + optimizations + inlining + double
  91. Bugzilla 23011: importC: asm label to set symbol name doesn't work with externs
  92. Bugzilla 23017: C++ class may not derive from D class
  93. Bugzilla 23025: ImportC: duplicate symbol for tentative definition and definition of variable
  94. Bugzilla 23028: ImportC: found _Generic instead of statement
  95. Bugzilla 23029: ImportC: _Generic treats pointer to const and regular pointers as the same type
  96. Bugzilla 23031: importC: hex character escapes should be variable length
  97. Bugzilla 23034: importC: head-const struct confused with multiple files on command line
  98. Bugzilla 23037: importC: type with only type-qualifier doesn't work
  99. Bugzilla 23038: importC: sizeof inside struct has struct members in scope
  100. Bugzilla 23039: importC: declaration with array length has itself in scope
  101. Bugzilla 23044: importC: comma expression with function call parsed as declaration
  102. Bugzilla 23045: importC: casted function type is missing extern(C)
  103. Bugzilla 23047: [ICE][SIMD] Do not SROA vector types
  104. Bugzilla 23056: importC: dmd asserts for missing return statement in CTFE function
  105. Bugzilla 23057: importC: dmd segfault on invalid syntax
  106. Bugzilla 23066: importC: cannot initialize char array with string literal of different length
  107. Bugzilla 23075: global const string definitions should go in readonly segment
  108. Bugzilla 23077: codegen cannot generage XMM load/store for optimized operation that uses byte/short/...
  109. Bugzilla 23083: .tupleof on static array rvalue evaluates expression multiple times

DMD Compiler enhancements

  1. Bugzilla 3632: modify float is float to do a bitwise compare
  2. Bugzilla 11463: DDoc html to show the normal escaped ASCII chars
  3. Bugzilla 14277: Compile-time array casting error - ugly error report
  4. Bugzilla 20853: static array ptr cannot be used in safe code but it should be allowed
  5. Bugzilla 21673: [SIMD][Win64] Wrong codegen for _mm_move_ss
  6. Bugzilla 22027: inout shouldn't imply return
  7. Bugzilla 22541: DIP1000: Resolve ambiguity of ref-return-scope parameters
  8. Bugzilla 22770: C++ header generator generates trailing newlines
  9. Bugzilla 22790: ref-return-scope is always ref-return, scope, unless return-scope appear in that order
  10. Bugzilla 22820: Error messages for slice pointers of structs with opIndex can be improved
  11. Bugzilla 22821: Dub package does not use incremental compilation
  12. Bugzilla 22861: Build the compiler with PGO
  13. Bugzilla 22880: importC: support __restrict__ __signed__ __asm__
  14. Bugzilla 22922: Support empty array literal in -betterC
  15. Bugzilla 22945: [Conditional Compilation] support invariant version flag
  16. Bugzilla 22967: [dip1000] no return ref inference for extended return semantics
  17. Bugzilla 23021: [dip1000] infer return scope from pure nothrow

Phobos regression fixes

  1. Bugzilla 20182: [REG 2.086.0] std.traits.ParameterDefaults fails for copy constructor of nested struct

Phobos bug fixes

  1. Bugzilla 13541: std.windows.syserror.sysErrorString() should be nothrow
  2. Bugzilla 18036: Documentation of moveFront() fails to mention different behavior depending on hasElaborateCopyConstructor
  3. Bugzilla 22213: Base64: Missing @nogc attribute on encodeLength
  4. Bugzilla 22503: Invalid changelog entry for isValidCodePoint
  5. Bugzilla 22771: BigInt divMod can return "-0" (negative zero)
  6. Bugzilla 22791: std\socket.d(790) Heisenbug random failure
  7. Bugzilla 22851: Missing reference to std.sumtype's source in the latter's documentation
  8. Bugzilla 22867: std.utf.decode changes offset despite error.
  9. Bugzilla 22873: Wrong std.format output for inout
  10. Bugzilla 22901: Can't construct inout SumType
  11. Bugzilla 22946: WindowsException ctor is not nothrow
  12. Bugzilla 22947: sysErrorString throws Exception instead of WindowsException
  13. Bugzilla 22998: Update to zlib 1.2.12

Phobos enhancements

  1. Bugzilla 22736: Add destructuring bind for std.typecons.Tuple tuples
  2. Bugzilla 22798: defaultGetoptPrinter should be @safe

Druntime regression fixes

  1. Bugzilla 22829: [REG master] Undefined symbol stderr first referenced in file test19933.o
  2. Bugzilla 22834: runnable_cxx/stdint.d: Undefined reference to _Z15testCppI8Mangleahahah

Druntime bug fixes

  1. Bugzilla 18117: ldiv_t struct in core.stdc.stdlib -- int vs c_long expectations
  2. Bugzilla 21631: core.atomic.cas fails to compile with const ifThis (if target is a pointer)
  3. Bugzilla 22763: importing std.utf fails in BetterC
  4. Bugzilla 22822: core.sys.posix.sys.stat: PPC stat_t bindings corrupt
  5. Bugzilla 22832: Can't destroy class with overloaded opCast
  6. Bugzilla 22843: Program hangs on full gc collect with --DRT-gcopt=fork:1 if run under valgrind/callgrind
  7. Bugzilla 23051: OpenBSD: Build broken on 2.100.0-beta.1 due to the inout attribute no longer implying the return attribute

Druntime enhancements

  1. Bugzilla 18816: [betterC] Standard Streams Unlinkable
  2. Bugzilla 19933: MSVC: Undefined std{in,out,err} with -betterC
  3. Bugzilla 22766: copyEmplace does not work with copy constructor and @disable this()
  4. Bugzilla 22964: array cast message is awkwardly worded

dlang.org bug fixes

  1. Bugzilla 15437: documentation for typeof(someTemplate) == void
  2. Bugzilla 22215: returning expired stack pointers in @system code allowed by spec, not by implementation
  3. Bugzilla 22795: Access denied when trying to download DMD 2.099.0-beta.1
  4. Bugzilla 22850: [Oh No! Page Not Found] Contract Programming
  5. Bugzilla 22959: Documentation for C/D main is incomplete

Installer bug fixes

  1. Bugzilla 22958: [Internal] Installer uses outdated image on Azure

Contributors to this release (41)

A huge thanks goes to all the awesome people who made this release possible.

previous version: 2.099.1