Hello community, here is the log from the commit of package dmd for openSUSE:Factory checked in at 2018-04-17 11:18:53 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/dmd (Old) and /work/SRC/openSUSE:Factory/.dmd.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "dmd" Tue Apr 17 11:18:53 2018 rev:14 rq:597226 version:2.079.1 Changes: -------- --- /work/SRC/openSUSE:Factory/dmd/dmd.changes 2018-04-11 14:05:04.484117105 +0200 +++ /work/SRC/openSUSE:Factory/.dmd.new/dmd.changes 2018-04-17 11:18:59.766252685 +0200 @@ -1,0 +2,23 @@ +Mon Apr 16 19:59:33 UTC 2018 - [email protected] + +- Update to 2.079.1 + - DMD Compiler regressions + * [REG 2.073] [DIP1000] Error on bad interplay of 'auto ref' and 'return' attribute deduction. + * DMD segmentation fault + - DMD Compiler bugs + * Enums are evaluated differently in global scope + * compiler segfault if new on a union type with dip1000 + - DMD Compiler enhancements + * Use of delete should be allowed without a deprecation in a deprecated scope + - Phobos regressions + * std.regex Captures opAssign returns void since v2.079.0 + * getSymbolsByUDA produces wrong result if one of the symbols having the UDA is a function + * assigning a std.regex.Captures with 3 or more groups causes double free + - Phobos bugs + * [2.079] std.format ignores templated toString if another toString is not a template + - Phobos enhancements + * Document the type of std.stdio.stdin and friends + - Druntime regressions + * [Reg 2.079] src/rt/tracegc.d(43): Deprecation: The delete keyword has been deprecated + +------------------------------------------------------------------- Old: ---- dmd-2.079.0.tar.gz druntime-2.079.0.tar.gz phobos-2.079.0.tar.gz New: ---- dmd-2.079.1.tar.gz druntime-2.079.1.tar.gz phobos-2.079.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ dmd.spec ++++++ --- /var/tmp/diff_new_pack.VkNfPu/_old 2018-04-17 11:19:04.802016644 +0200 +++ /var/tmp/diff_new_pack.VkNfPu/_new 2018-04-17 11:19:04.802016644 +0200 @@ -24,7 +24,7 @@ %define auto_bootstrap 1 %endif Name: dmd -Version: 2.079.0 +Version: 2.079.1 Release: 0 Summary: D Programming Language 2.0 License: BSL-1.0 ++++++ dmd-2.079.0.tar.gz -> dmd-2.079.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/VERSION new/dmd-2.079.1/VERSION --- old/dmd-2.079.0/VERSION 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/VERSION 2018-04-14 18:11:03.000000000 +0200 @@ -1 +1 @@ -v2.079.0 +v2.079.1 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/argument-mismatch.dd new/dmd-2.079.1/changelog/argument-mismatch.dd --- old/dmd-2.079.0/changelog/argument-mismatch.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/argument-mismatch.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,22 +0,0 @@ -Argument mismatch errors have been improved - -$(P `dmd` now shows which argument failed to match a parameter with an explanatory error message.) ---- -void fill(ref char[16] buf, char c); - -void main() -{ - fill("1234567890123456", '*'); - - const char[16] s; - fill(s, '*'); -} ---- -$(P Output:) -$(CONSOLE -fillchar.d(5): Error: function `fillchar.fill(ref char[16] buf, char c)` is not callable using argument types `(string, char)` -fillchar.d(5): cannot pass rvalue argument `"1234567890123456"` of type `string` to parameter `ref char[16] buf` -fillchar.d(8): Error: function `fillchar.fill(ref char[16] buf, char c)` is not callable using argument types `(const(char[16]), char)` -fillchar.d(8): cannot pass argument `s` of type `const(char[16])` to parameter `ref char[16] buf` -) -$(P Note: Currently this change doesn't apply when the function has overloads.) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/comma-deprecation-error.dd new/dmd-2.079.1/changelog/comma-deprecation-error.dd --- old/dmd-2.079.0/changelog/comma-deprecation-error.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/comma-deprecation-error.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,67 +0,0 @@ -The deprecation period of using the result of comma expression has ended - -Comma expressions have proven to be a frequent source of confusion, and bugs. -Using their result will now trigger an error message. - -$(P The comma operator (`,`) allows executing multiple expressions and - discards the result of them except for the last which is returned. - - --- - int a = 1; - int b = 2; - bool ret = a == 2, b == 2; // true - --- - - It's also common to use the comma operator in for-loop increment - statements to allow multiple expressions. - - --- - for (; !a.empty && !b.empty; a.popFront, b.popFront) - --- - - Hence, using the comma operator in for-loop increment statements is still allowed. -) -$(H4 Corrective Action) -$(P If possible, split the comma operator in two statements. Otherwise use - lambdas. - - --- - auto result = foo(), bar(); - - // split off in two statements - foo(); - auto result = bar(); - - // or use lambdas - auto result = {foo(); return bar();}(); - --- -) -$(H4 Rationale) -$(P The comma operator leads to unintended behavior (see below for a selection) - Moreover it is not commonly used and it blocks the ability to implement tuples - as a language feature using commas. - - A selection of problems through the accidental use of the comma operator: - --- - writeln( 6, mixin("7,8"), 9 ); // 6, 8, 9 - - struct Vec - { - this(T...)(T args) { ... } - } - // missing type name - Vec v = (0, 0, 3); // Vec(3) - - int a = 0; - int b = 2; - if (a == 1, b == 2) { - // will always be reached - } - - void foo(int x, int y=0) {} - foo((a, b)); // Oops, foo(b) is called - - synchronized (lockA, lockB) {} - // multiple expressions aren't currently implemented, but it compiles due to the comma operator - --- -) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/default_after_variadic.dd new/dmd-2.079.1/changelog/default_after_variadic.dd --- old/dmd-2.079.0/changelog/default_after_variadic.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/default_after_variadic.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,22 +0,0 @@ -Function parameters with default values are now allowed after variadic template parameters - -Function parameters with default values are now allowed after variadic template parameters -and when IFTI is used, always take their default values. -This allows using special tokens (eg `__FILE__`) after variadic parameters, which was previously impossible. - -For example: - ---- -string log(T...)(T a, string file = __FILE__, int line = __LINE__) -{ - return text(file, ":", line, " ", a); -} - -assert(log(10, "abc") == text(__FILE__, ":", __LINE__, " 10abc")); ---- - -This should be preferred to the previous workaround, which causes a new template instantiation -for every invocation: ---- -string log(string file = __FILE__, int line = __LINE__, T...)(T a); ---- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/deprecate_delete.dd new/dmd-2.079.1/changelog/deprecate_delete.dd --- old/dmd-2.079.0/changelog/deprecate_delete.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/deprecate_delete.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,8 +0,0 @@ -The `delete` keyword has been deprecated. - -See the $(LINK2 $(ROOT_DIR)deprecate.html#delete, Deprecated Features) for more information. - -Starting with this release, using the `delete` keyword will result in a deprecation warning. - -As a replacement, users are encouraged to use $(REF1 destroy, object) -if feasible, or $(REF __delete, core,memory) as a last resort. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/deprecation-dylib.dd new/dmd-2.079.1/changelog/deprecation-dylib.dd --- old/dmd-2.079.0/changelog/deprecation-dylib.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/deprecation-dylib.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,9 +0,0 @@ -The deprecation period of the `-dylib` flag on OSX has ended. Use `-shared` - -The deprecation period of the `-dylib` flag on OSX has ended. - -$(CONSOLE dmd -dylib awesome_d_library.d) - -Use the `-shared` flag to generate a shared library: - -$(CONSOLE dmd -shared awesome_d_library.d) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/dip1008.dd new/dmd-2.079.1/changelog/dip1008.dd --- old/dmd-2.079.0/changelog/dip1008.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/dip1008.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,12 +0,0 @@ -Experimental `@nogc` Exception throwing with `-dip1008` - -[DIP1008](https://github.com/dlang/DIPs/blob/master/DIPs/DIP1008.md) has been merged and it can be previewed under the experimental `-dip1008` flag: - ---- -void main() @nogc -{ - throw new Exception("I'm @nogc now"); -} ---- - -$(CONSOLE rdmd -dip1008 app.d) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/disabled-trait.dd new/dmd-2.079.1/changelog/disabled-trait.dd --- old/dmd-2.079.0/changelog/disabled-trait.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/disabled-trait.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,43 +0,0 @@ -A compiler trait used to detect if a function is marked with `@disable` has been added. - -Prior to this release is was impossible to filter out `@disable` functions without -using `__trait(compiles)`, which was less than ideal since `false` could be -returned for other reasons. - -Now, in metaprogramming code, `@disable` functions can be detected accurately, -using `__traits(isDisabled)` and even in overload sets: - ---- -module runnable; - -struct Foo -{ - import std.stdio; - @disable static void foo() {__PRETTY_FUNCTION__.writeln;} - static void foo(int v) {__PRETTY_FUNCTION__.writeln;} - static void bar() {__PRETTY_FUNCTION__.writeln;} - @disable static void bar(int v) {__PRETTY_FUNCTION__.writeln;} -} - -void test(T)() -{ - foreach (member; __traits(allMembers, T)) - foreach (overload; __traits(getOverloads, T, member)) - static if (!__traits(isDisabled, overload)) - { - static if (is(typeof(&overload) == void function())) - overload(); - else static if (is(typeof(&overload) == void function(int))) - overload(42); - } -} - -void main(){test!Foo;} ---- - -prints: - -$(CONSOLE -void runnable.Foo.foo(int v) -void runnable.Foo.bar() -) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/fix17630.dd new/dmd-2.079.1/changelog/fix17630.dd --- old/dmd-2.079.0/changelog/fix17630.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/fix17630.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,21 +0,0 @@ -Fix Issue 17630 - selective imports find symbols in private imports of other modules - -Selectively importing a symbol should work only if the symbol -imported is defined or publicly imported in the imported module. -Due to a compiler bug, selectively importing a symbol works even -if the symbol is defined in a privately imported module in the -imported module. ------------------------------------------------------------ -//a.d -int bar; - -//b.d -import a; - -//c.d -import b : bar; ------------------------------------------------------------- -The above code will now result in a deprecation message -which states that `bar` cannot be accessed since it is -privately imported in `b`. - diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/fix17899.dd new/dmd-2.079.1/changelog/fix17899.dd --- old/dmd-2.079.0/changelog/fix17899.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/fix17899.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,8 +0,0 @@ -Fix issue 17899 - Allow delegates to be initialised at compile time - -delegates may now be initialised at module scope. This changes the effect of the fix for 13259 (turning the ICE that resulted into an error) making the follow legal: ---- -void delegate() bar = (){}; ---- - -The function pointer is set to the function of the delegate, the context pointer is set to null. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/fix18053.dd new/dmd-2.079.1/changelog/fix18053.dd --- old/dmd-2.079.0/changelog/fix18053.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/fix18053.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,16 +0,0 @@ -Fix Issue 18053 - mangle long/ulong as int64_t/uint64_t - -This is a breaking change (on OSX 64). - -Due to the erratic implementation defined behavior of C++ name mangling, it was -difficult to get D's long/ulong to portably match up with the corresponding -C++ compiler. - -By instead relying on how the corresponding C++ compiler mangled int64_t/uint64_t -it makes the C++ side of the D<=>C++ interface much simpler. - -For the current platforms dmd supports, only the OSX 64 bit mangling changes. In -this case from 'm' to 'y'. - -Note: - int64_t and uint64_t are defined in stdint.h diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/fix18219.dd new/dmd-2.079.1/changelog/fix18219.dd --- old/dmd-2.079.0/changelog/fix18219.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/fix18219.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,8 +0,0 @@ -Fix Issue 18219 - Private import inside struct leaks symbols when used as VarDeclaration types - -When implementing a struct which has a local private import -the imported symbols are leaked if present in a VarDeclaration statement. For more information and examples see : https://issues.dlang.org/show_bug.cgi?id=18219 - -Symbols from the private import should not visible outside the -struct scope. A deprecation is now issued when such cases are -encountered diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/fix18361.dd new/dmd-2.079.1/changelog/fix18361.dd --- old/dmd-2.079.0/changelog/fix18361.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/fix18361.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,37 +0,0 @@ -Fix issue 18361 - Ddoc ability to opt-out of automatic keyword highlighting in running text - -Currently, ddoc automatically highlights all occurrences of words in running -text that coincide with the symbol or module being documented, or a parameter -name of a function being documented. While convenient, it often caused -unintended highlighting of normal words in text when module, function, or -parameter identifiers coincide with normal words. This led to a proliferation -of prefixing words with `_` in order to suppress this behaviour. - -Now a better solution has been implemented to completely opt-out of this -feature via the `DDOC_AUTO_PSYMBOL`, `DDOC_AUTO_KEYWORD`, and `DDOC_AUTO_PARAM` -macros, which are used for all such automatically-highlighted words in running -text. Occurrences of module, function, or parameter names inside code blocks -are not included. By default, these macros simply redirect to `DDOC_PSYMBOL`, -`DDOC_KEYWORD`, and `DDOC_PARAM`, but the user can now redefine these macros so -that they simply expand to the word itself without any highlighting: - ----- -DDOC_AUTO_PSYMBOL = $0 -DDOC_AUTO_KEYWORD = $0 -DDOC_AUTO_PARAM = $0 ----- - -Furthermore, whenever a word is prefixed with `_` to suppress automatic -highlighting, it is now wrapped in the `DDOC_AUTO_PSYMBOL_SUPPRESS` macro. This -is to provide users who wish to opt out of automatic highlighting an easy way -to find all occurrences of these underscore prefixes so that they can be -removed from the text. For example, they can redefine this macro to something -highly-visible and easily searched for, such as: - ----- -DDOC_AUTO_PSYMBOL_SUPPRESS = FIXME_UNDERSCORE_PREFIX $0 ----- - -and then search the generated documentation for the string -`FIXME_UNDERSCORE_PREFIX` and delete the `_` prefix from all corresponding -parts of the documentation comment text. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/fix8207.dd new/dmd-2.079.1/changelog/fix8207.dd --- old/dmd-2.079.0/changelog/fix8207.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/fix8207.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,8 +0,0 @@ -D ABI change on Win32 and OSX targets - -The compiler has been updated to prefix all `extern(D)` symbols with an extra -underscore where the platform expects one on all external symbols. This allows -compiled code to work better with binutil programs, such as the ability to list -symbols demangled inside a debugger. - -This is an ABI breaking change and requires recompiling libraries. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/hexstrings.dd new/dmd-2.079.1/changelog/hexstrings.dd --- old/dmd-2.079.0/changelog/hexstrings.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/hexstrings.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,4 +0,0 @@ -HexString literals are deprecated. - -$(LINK2 http://dlang.org/spec/lex.html#HexString, HexString literals) are deprecated. -Use $(LINK2 https://dlang.org/phobos/std_conv.html#hexString, `std.conv.hexString`) instead. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/includeimports.dd new/dmd-2.079.1/changelog/includeimports.dd --- old/dmd-2.079.0/changelog/includeimports.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/includeimports.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,9 +0,0 @@ -Added the `-i` command line option to automatically include imports - -Added the command line option `-i` which causes the compiler to treat imported modules as if they were given on the command line. The option also accepts "module patterns" that include/exclude modules based on their name. For example, the following will include all modules whose names start with `foo`, except for those that start with `foo.bar`: - -$(CONSOLE dmd -i=foo -i=-foo.bar) - -The option `-i` by itself is equivalent to: - -$(CONSOLE dmd -i=-std -i=-core -i=-etc -i=-object) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/json_includes.dd new/dmd-2.079.1/changelog/json_includes.dd --- old/dmd-2.079.0/changelog/json_includes.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/json_includes.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,47 +0,0 @@ -Added `-Xi=<name>` to include more fields in the JSON output - -Added `-Xi=<name>` to include more fields in the JSON output. Currently there are 4 fields that can be included: "compilerInfo", "buildInfo", "modules" and "semantics", i.e. - -$(CONSOLE dmd -Xi=compilerInfo -Xi=buildInfo -Xi=semantics -Xi=modules) - -will generate a JSON file with the following: ---- -{ - "compilerInfo" : { - "binary" : "<filename-of-compiler-binary>", - "version" : "<compiler-version>", - "supportsIncludeImports" : true, - }, - "buildInfo" : { - "config" : "<config-filename>", - "cwd" : "<cwd-during-build>", - "importParths" : [ - "<import-path1>", - "<import-path2>", - // ... - ] - }, - "semantics" : { - "modules" : [ - { - "name" : "<module-name>", - "file" : "<module-filename>", - "isRoot" : true|false - }, - // more module objects... - ] - }, - "modules" : [ - // an array of the syntax data for all the modules, - // this is the same array that would be generated - // for a JSON file with no -Xi=<field> options - ] -} ---- -If JSON is generated without any `-Xi=` options then the old format is used. The old format is the same data that would appear in the new "modules" field. - -Also note that the compiler can now be invoked with no source files as long as at least one JSON field is provided, i.e. - -$(CONSOLE dmd -Xi=compilerInfo) - -$(RED This is an experimental command-line flag and will be stabilized in the next release.) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/lambdacomp.dd new/dmd-2.079.1/changelog/lambdacomp.dd --- old/dmd-2.079.0/changelog/lambdacomp.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/lambdacomp.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,22 +0,0 @@ -Lambda comparison using `__traits(isSame, ...)` - -It is now possible to compare two lambda functions, under certain -constraints, using `__traits(isSame, lamda1, lambda2)`. In order to -correctly compare two lambdas, the following conditions must be -satisfied: - -$(UL - $(LI the lambda function arguments must not have a template instantiation - as an explicit argument type. Any other argument types (basic, - user-defined, template) are supported.) - $(LI the lambda function body must contain a single expression (no return statement) - which contains only numeric values, manifest constants, enum values and arguments. - If the expression contains local variables, function calls or return statements, - the function is considered uncomparable.) -) - -These limitations might be lifted in the next release version. - -Whenever a lambda is considered uncomparable, the `__traits(isSame, ...)` expression -in which it's used will return false, no matter what other lambda is used in -the comparison. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/lld_mingw.dd new/dmd-2.079.1/changelog/lld_mingw.dd --- old/dmd-2.079.0/changelog/lld_mingw.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/lld_mingw.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,7 +0,0 @@ -Windows: Visual C++ and the Windows SDK are no longer required to build 64-bit executables - -The Windows installer now adds platform libraries built from the MinGW definitions and -a wrapper library for the VC2010 shared C runtime. When building COFF object files with -`-m64` or `-m32mscoff` and no Visual Studio installation is detected or -no platform libraries are found these will be used as replacements. If the Microsoft linker -is not found, the LLVM linker LLD will be used. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/minimal_runtime.dd new/dmd-2.079.1/changelog/minimal_runtime.dd --- old/dmd-2.079.0/changelog/minimal_runtime.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/minimal_runtime.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,107 +0,0 @@ -Using D with no/minimal/custom runtime implementation in a pay-as-you-go fashion - -$(P DMD has been further decoupled from the runtime so it is now easier and more -convenient to use D without the runtime in a pay-as-you-go fashion. This will -be of interest to users wishing to incrementally or partially port D to new -platforms, users targeting bare-metal or resource constrained platforms, and -users wishing to use D as a library from other languages without the runtime.) - -$(P Prior to this release, if one attempted to compile a simple D application that -made no use of any runtime features, the compiler would have emitted a number -of errors about a missing object.d, a missing `Error` class, missing `TypeInfo`, -and missing `ModuleInfo`, among others.) - -$(P Starting with this release, one can now create a library for use from another -language, requiring only the `.d` source file that implements that library, and -an empty `object.d` file) - -$(B Example 1) ---- -module object ---- - ---- -module math; - -extern(C) int add(int a, int b) -{ - return a + b; -} ---- - -$(CONSOLE -dmd -conf= -lib math.d -size math.a - text data bss dec hex filename - 0 0 0 0 0 math.o (ex math.a) - 20 0 0 20 14 math_1_129.o (ex math.a) -) - -$(P Also, starting with this release, one can now create very small executables -with a minimal runtime implementation.) - -$(B Example 2) -$(P DMD auto-generates a call to `_d_run_main` which, in turn, calls the user-defined -`main` function. DMD automatically generates a call to `g++` which links in the C runtime.) ---- -module object; - -private alias extern(C) int function(char[][] args) MainFunc; -private extern (C) int _d_run_main(int argc, char** argv, MainFunc mainFunc) -{ - return mainFunc(null); // assumes `void main()` for simplicity -} ---- - ---- -module main; - -void main() { } ---- - -$(CONSOLE -dmd -conf= -defaultlib= -fPIC main.d object.d -of=main -size main - text data bss dec hex filename - 1403 584 16 2003 7d3 main -) - -$(B Example 3) -$(P Manually generated call to `main`. No C runtime.) ---- -module object; - -extern(C) void __d_sys_exit(long arg1) -{ - asm - { - mov RAX, 60; - mov RDI, arg1; - syscall; - } -} - -extern void main(); -private extern(C) void _start() -{ - main(); - __d_sys_exit(0); -} ---- - ---- -module main; - -void main() { } ---- - -$(CONSOLE -dmd -c -lib main.d object.d -of=main.o -ld main.o -o main -size main - text data bss dec hex filename - 56 0 0 56 38 main -) - -$(P Usage of more advanced D features (e.g. classes, exceptions, etc...) will require -runtime implementation code, but they can be implemented in a pay-as-you-go fashion.) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/osx-10_9.dd new/dmd-2.079.1/changelog/osx-10_9.dd --- old/dmd-2.079.0/changelog/osx-10_9.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/osx-10_9.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,7 +0,0 @@ -macOS deployment target was increased to 10.9 - -The compiler has been updated to use 10.9 and link with `libc++` on OSX. -This is due the shared `libstdc++` library from older versions of macOS -having compatibility issues with the headers included in a modern XCode. - -The minimum required version of running the compiler is now Mac OS X Mavericks (10.9). diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/private.dd new/dmd-2.079.1/changelog/private.dd --- old/dmd-2.079.0/changelog/private.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/private.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,8 +0,0 @@ -Deprecate the use of selectively imported private members - -$(LINK2 $(ROOT_DIR)spec/attribute.html#visibility_attributes, The specification states) that a private member -is visible only from within the same module. -Prior to this release, due to a bug, private members -were visible through selective imports from other modules, violating the specification. -Beginning with this release, accessing private members from outside the module -in which they are declared will result in a deprecation message. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/changelog/ptr-safe-end-of-deprecation.dd new/dmd-2.079.1/changelog/ptr-safe-end-of-deprecation.dd --- old/dmd-2.079.0/changelog/ptr-safe-end-of-deprecation.dd 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/changelog/ptr-safe-end-of-deprecation.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,26 +0,0 @@ -`.ptr` on arrays can no longer be used in `@safe` code - -The deprecation period for using `.ptr` on arrays in `@safe` ended. -The following now triggers an error instead of a deprecation: - ---- -@safe ubyte* oops(ubyte[] arr) { - return arr.ptr; -} ---- - -Use `&arr[0]` instead: - ---- -@safe ubyte* oops(ubyte[] arr) { - return &arr[0]; -} ---- - -Note that this only applies to SafeD - in `@system` code `.ptr` may still be used: - ---- -@system ubyte* oops(ubyte[] arr) { - return arr.ptr; -} ---- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/semaphoreci.sh new/dmd-2.079.1/semaphoreci.sh --- old/dmd-2.079.0/semaphoreci.sh 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/semaphoreci.sh 2018-04-14 18:11:03.000000000 +0200 @@ -16,8 +16,20 @@ export N=4 export OS_NAME=linux -export BRANCH=$BRANCH_NAME export FULL_BUILD="${PULL_REQUEST_NUMBER+false}" +# SemaphoreCI doesn't provide a convenient way to the base branch (e.g. master or stable) +if [ -n "${PULL_REQUEST_NUMBER:-}" ]; then + # detect master/stable without querying the rate-limited API + BRANCH="$(git describe --all | sed -E "s/.*\/([^-/]*)-.*/\1/")" + # check if the detected branch actually exists and fallback to master + if ! git ls-remote --exit-code --heads https://github.com/dlang/dmd.git "$BRANCH" > /dev/null ; then + echo "Invalid branch detected: ${BRANCH} - falling back to master" + BRANCH="master" + fi +else + BRANCH="${BRANCH_NAME}" +fi +export BRANCH source ci.sh diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/src/dmd/dsymbolsem.d new/dmd-2.079.1/src/dmd/dsymbolsem.d --- old/dmd-2.079.0/src/dmd/dsymbolsem.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/src/dmd/dsymbolsem.d 2018-04-14 18:11:03.000000000 +0200 @@ -2039,7 +2039,10 @@ return errorReturn(); Expression eprev = emprev.value; - Type tprev = eprev.type.equals(em.ed.type) ? em.ed.memtype : eprev.type; + // .toHeadMutable() due to https://issues.dlang.org/show_bug.cgi?id=18645 + Type tprev = eprev.type.toHeadMutable().equals(em.ed.type.toHeadMutable()) + ? em.ed.memtype + : eprev.type; Expression emax = tprev.getProperty(em.ed.loc, Id.max, 0); emax = emax.expressionSemantic(sc); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/src/dmd/expressionsem.d new/dmd-2.079.1/src/dmd/expressionsem.d --- old/dmd-2.079.0/src/dmd/expressionsem.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/src/dmd/expressionsem.d 2018-04-14 18:11:03.000000000 +0200 @@ -2353,7 +2353,7 @@ { foreach (arg; *exp.arguments) { - if (checkReturnEscape(sc, arg, false)) + if (arg && checkReturnEscape(sc, arg, false)) return setError(); } } @@ -5130,6 +5130,16 @@ override void visit(DeleteExp exp) { + if (!sc.isDeprecated) + { + // @@@DEPRECATED_2019-02@@@ + // 1. Deprecation for 1 year + // 2. Error for 1 year + // 3. Removal of keyword, "delete" can be used for other identities + if (!exp.isRAII) + deprecation(exp.loc, "The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead."); + } + if (Expression ex = unaSemantic(exp, sc)) { result = ex; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/src/dmd/parse.d new/dmd-2.079.1/src/dmd/parse.d --- old/dmd-2.079.0/src/dmd/parse.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/src/dmd/parse.d 2018-04-14 18:11:03.000000000 +0200 @@ -7758,11 +7758,6 @@ case TOK.delete_: nextToken(); e = parseUnaryExp(); - // @@@DEPRECATED_2019-02@@@ - // 1. Deprecation for 1 year - // 2. Error for 1 year - // 3. Removal, "delete" can be used for other identities - deprecation("The `delete` keyword has been deprecated. Use `object.destroy()` instead."); e = new AST.DeleteExp(loc, e, false); break; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/src/dmd/semantic2.d new/dmd-2.079.1/src/dmd/semantic2.d --- old/dmd-2.079.0/src/dmd/semantic2.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/src/dmd/semantic2.d 2018-04-14 18:11:03.000000000 +0200 @@ -237,6 +237,13 @@ //printf("VarDeclaration::semantic2('%s')\n", toChars()); + if (vd.aliassym) // if it's a tuple + { + vd.aliassym.accept(this); + vd.semanticRun = PASS.semantic2done; + return; + } + if (vd._init && !vd.toParent().isFuncDeclaration()) { vd.inuse++; @@ -563,7 +570,7 @@ override void visit(AggregateDeclaration ad) { - //printf("AggregateDeclaration::semantic2(%s) type = %s, errors = %d\n", toChars(), type.toChars(), errors); + //printf("AggregateDeclaration::semantic2(%s) type = %s, errors = %d\n", ad.toChars(), ad.type.toChars(), ad.errors); if (!ad.members) return; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/src/dmd/statementsem.d new/dmd-2.079.1/src/dmd/statementsem.d --- old/dmd-2.079.0/src/dmd/statementsem.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/src/dmd/statementsem.d 2018-04-14 18:11:03.000000000 +0200 @@ -3060,16 +3060,25 @@ { /* Determine "refness" of function return: * if it's an lvalue, return by ref, else return by value + * https://dlang.org/spec/function.html#auto-ref-functions */ + + void turnOffRef() + { + tf.isref = false; // return by value + tf.isreturn = false; // ignore 'return' attribute, whether explicit or inferred + fd.storage_class &= ~STC.return_; + } + if (rs.exp.isLvalue()) { /* May return by ref */ if (checkReturnEscapeRef(sc, rs.exp, true)) - tf.isref = false; // return by value + turnOffRef(); } else - tf.isref = false; // return by value + turnOffRef(); /* The "refness" is determined by all of return statements. * This means: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/compilable/test17512.d new/dmd-2.079.1/test/compilable/test17512.d --- old/dmd-2.079.0/test/compilable/test17512.d 1970-01-01 01:00:00.000000000 +0100 +++ new/dmd-2.079.1/test/compilable/test17512.d 2018-04-14 18:11:03.000000000 +0200 @@ -0,0 +1,15 @@ +// https://issues.dlang.org/show_bug.cgi?id=17512 + +struct A +{ + int _value; + + bool _hasValue; + + auto ref getOr(int alternativeValue) + { + return _hasValue ? _value : alternativeValue; + } +} + +A a; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/compilable/test17906.d new/dmd-2.079.1/test/compilable/test17906.d --- old/dmd-2.079.0/test/compilable/test17906.d 1970-01-01 01:00:00.000000000 +0100 +++ new/dmd-2.079.1/test/compilable/test17906.d 2018-04-14 18:11:03.000000000 +0200 @@ -0,0 +1,7 @@ +// REQUIRED_ARGS: -de +// https://issues.dlang.org/show_bug.cgi?id=18647 +deprecated void main () +{ + Object o = new Object; + delete o; +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/compilable/test17942.d new/dmd-2.079.1/test/compilable/test17942.d --- old/dmd-2.079.0/test/compilable/test17942.d 1970-01-01 01:00:00.000000000 +0100 +++ new/dmd-2.079.1/test/compilable/test17942.d 2018-04-14 18:11:03.000000000 +0200 @@ -0,0 +1,15 @@ +// https://issues.dlang.org/show_bug.cgi?id=17942 + +alias AliasSeq(TList...) = TList; + +void test() +{ + enum A = AliasSeq!(1); + static assert(A[0] == 1); + static assert(B[0] == 2); +} + +enum B = AliasSeq!(2); + +enum C = AliasSeq!(); + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/compilable/test18645.d new/dmd-2.079.1/test/compilable/test18645.d --- old/dmd-2.079.0/test/compilable/test18645.d 1970-01-01 01:00:00.000000000 +0100 +++ new/dmd-2.079.1/test/compilable/test18645.d 2018-04-14 18:11:03.000000000 +0200 @@ -0,0 +1,9 @@ +// https://issues.dlang.org/show_bug.cgi?id=18645 + +immutable INIT = 42; + +enum A +{ + x = INIT, + y +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/compilable/test18670.d new/dmd-2.079.1/test/compilable/test18670.d --- old/dmd-2.079.0/test/compilable/test18670.d 1970-01-01 01:00:00.000000000 +0100 +++ new/dmd-2.079.1/test/compilable/test18670.d 2018-04-14 18:11:03.000000000 +0200 @@ -0,0 +1,12 @@ +// REQUIRED_ARGS: -dip1000 + +// https://issues.dlang.org/show_bug.cgi?id=18670 + +void foo() { + new OVERLAPPED; +} + +union OVERLAPPED { + uint OffsetHigh; + uint Pointer; +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/compilable/vgc1.d new/dmd-2.079.1/test/compilable/vgc1.d --- old/dmd-2.079.0/test/compilable/vgc1.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/test/compilable/vgc1.d 2018-04-14 18:11:03.000000000 +0200 @@ -1,15 +1,6 @@ // REQUIRED_ARGS: -vgc -o- // PERMUTE_ARGS: -/* -TEST_OUTPUT: ---- -compilable/vgc1.d(93): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -compilable/vgc1.d(94): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -compilable/vgc1.d(95): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. ---- -*/ - /***************** NewExp *******************/ struct S1 { } @@ -21,13 +12,13 @@ /* TEST_OUTPUT: --- -compilable/vgc1.d(36): vgc: `new` causes a GC allocation +compilable/vgc1.d(27): vgc: `new` causes a GC allocation +compilable/vgc1.d(29): vgc: `new` causes a GC allocation +compilable/vgc1.d(30): vgc: `new` causes a GC allocation +compilable/vgc1.d(32): vgc: `new` causes a GC allocation +compilable/vgc1.d(33): vgc: `new` causes a GC allocation +compilable/vgc1.d(34): vgc: `new` causes a GC allocation compilable/vgc1.d(38): vgc: `new` causes a GC allocation -compilable/vgc1.d(39): vgc: `new` causes a GC allocation -compilable/vgc1.d(41): vgc: `new` causes a GC allocation -compilable/vgc1.d(42): vgc: `new` causes a GC allocation -compilable/vgc1.d(43): vgc: `new` causes a GC allocation -compilable/vgc1.d(47): vgc: `new` causes a GC allocation --- */ @@ -50,12 +41,12 @@ /* TEST_OUTPUT: --- -compilable/vgc1.d(64): vgc: `new` causes a GC allocation -compilable/vgc1.d(66): vgc: `new` causes a GC allocation -compilable/vgc1.d(67): vgc: `new` causes a GC allocation -compilable/vgc1.d(69): vgc: `new` causes a GC allocation -compilable/vgc1.d(70): vgc: `new` causes a GC allocation -compilable/vgc1.d(71): vgc: `new` causes a GC allocation +compilable/vgc1.d(55): vgc: `new` causes a GC allocation +compilable/vgc1.d(57): vgc: `new` causes a GC allocation +compilable/vgc1.d(58): vgc: `new` causes a GC allocation +compilable/vgc1.d(60): vgc: `new` causes a GC allocation +compilable/vgc1.d(61): vgc: `new` causes a GC allocation +compilable/vgc1.d(62): vgc: `new` causes a GC allocation --- */ @@ -83,9 +74,12 @@ /* TEST_OUTPUT: --- -compilable/vgc1.d(93): vgc: `delete` requires the GC -compilable/vgc1.d(94): vgc: `delete` requires the GC -compilable/vgc1.d(95): vgc: `delete` requires the GC +compilable/vgc1.d(87): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +compilable/vgc1.d(87): vgc: `delete` requires the GC +compilable/vgc1.d(88): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +compilable/vgc1.d(88): vgc: `delete` requires the GC +compilable/vgc1.d(89): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +compilable/vgc1.d(89): vgc: `delete` requires the GC --- */ void testDelete(int* p, Object o, S1* s) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/d_do_test.d new/dmd-2.079.1/test/d_do_test.d --- old/dmd-2.079.0/test/d_do_test.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/test/d_do_test.d 2018-04-14 18:11:03.000000000 +0200 @@ -569,7 +569,7 @@ { case "win32": envData.ccompiler = "dmc"; break; case "win64": envData.ccompiler = `\"Program Files (x86)"\"Microsoft Visual Studio 10.0"\VC\bin\amd64\cl.exe`; break; - default: envData.ccompiler = "g++"; break; + default: envData.ccompiler = "c++"; break; } } bool msc = envData.ccompiler.toLower.endsWith("cl.exe"); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/fail_compilation/fail14486.d new/dmd-2.079.1/test/fail_compilation/fail14486.d --- old/dmd-2.079.0/test/fail_compilation/fail14486.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/test/fail_compilation/fail14486.d 2018-04-14 18:11:03.000000000 +0200 @@ -1,41 +1,5 @@ // REQUIRED_ARGS: -o- -/* -TEST_OUTPUT: ---- -fail_compilation/fail14486.d(81): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(82): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(83): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(84): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(85): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(99): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(100): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(101): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(102): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(103): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(123): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(124): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(125): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(126): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(127): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(141): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(142): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(143): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(144): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(145): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(164): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(165): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(166): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(167): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(168): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(181): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(182): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(183): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(184): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/fail14486.d(185): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. ---- -*/ - class C0a { } class C1a { ~this() {} } class C2a { ~this() {} @nogc pure @safe delete(void* p) {} } @@ -63,17 +27,22 @@ /* TEST_OUTPUT: --- -fail_compilation/fail14486.d(81): Error: `delete c0` is not `@safe` but is used in `@safe` function `test1a` -fail_compilation/fail14486.d(82): Error: `pure` function `fail14486.test1a` cannot call impure destructor `fail14486.C1a.~this` -fail_compilation/fail14486.d(82): Error: `@safe` function `fail14486.test1a` cannot call `@system` destructor `fail14486.C1a.~this` -fail_compilation/fail14486.d(82): Error: `@nogc` function `fail14486.test1a` cannot call non-@nogc destructor `fail14486.C1a.~this` -fail_compilation/fail14486.d(83): Error: `pure` function `fail14486.test1a` cannot call impure destructor `fail14486.C2a.~this` -fail_compilation/fail14486.d(83): Error: `@safe` function `fail14486.test1a` cannot call `@system` destructor `fail14486.C2a.~this` -fail_compilation/fail14486.d(83): Error: `@nogc` function `fail14486.test1a` cannot call non-@nogc destructor `fail14486.C2a.~this` -fail_compilation/fail14486.d(84): Error: `pure` function `fail14486.test1a` cannot call impure deallocator `fail14486.C3a.delete` -fail_compilation/fail14486.d(84): Error: `@safe` function `fail14486.test1a` cannot call `@system` deallocator `fail14486.C3a.delete` -fail_compilation/fail14486.d(84): Error: `@nogc` function `fail14486.test1a` cannot call non-@nogc deallocator `fail14486.C3a.delete` -fail_compilation/fail14486.d(85): Error: `delete c4` is not `@safe` but is used in `@safe` function `test1a` +fail_compilation/fail14486.d(50): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(50): Error: `delete c0` is not `@safe` but is used in `@safe` function `test1a` +fail_compilation/fail14486.d(51): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(51): Error: `pure` function `fail14486.test1a` cannot call impure destructor `fail14486.C1a.~this` +fail_compilation/fail14486.d(51): Error: `@safe` function `fail14486.test1a` cannot call `@system` destructor `fail14486.C1a.~this` +fail_compilation/fail14486.d(51): Error: `@nogc` function `fail14486.test1a` cannot call non-@nogc destructor `fail14486.C1a.~this` +fail_compilation/fail14486.d(52): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(52): Error: `pure` function `fail14486.test1a` cannot call impure destructor `fail14486.C2a.~this` +fail_compilation/fail14486.d(52): Error: `@safe` function `fail14486.test1a` cannot call `@system` destructor `fail14486.C2a.~this` +fail_compilation/fail14486.d(52): Error: `@nogc` function `fail14486.test1a` cannot call non-@nogc destructor `fail14486.C2a.~this` +fail_compilation/fail14486.d(53): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(53): Error: `pure` function `fail14486.test1a` cannot call impure deallocator `fail14486.C3a.delete` +fail_compilation/fail14486.d(53): Error: `@safe` function `fail14486.test1a` cannot call `@system` deallocator `fail14486.C3a.delete` +fail_compilation/fail14486.d(53): Error: `@nogc` function `fail14486.test1a` cannot call non-@nogc deallocator `fail14486.C3a.delete` +fail_compilation/fail14486.d(54): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(54): Error: `delete c4` is not `@safe` but is used in `@safe` function `test1a` --- */ void test1a() @nogc pure @safe @@ -88,10 +57,15 @@ /* TEST_OUTPUT: --- -fail_compilation/fail14486.d(100): Error: destructor `fail14486.C1b.~this` is not `nothrow` -fail_compilation/fail14486.d(101): Error: destructor `fail14486.C2b.~this` is not `nothrow` -fail_compilation/fail14486.d(102): Error: deallocator `fail14486.C3b.delete` is not `nothrow` -fail_compilation/fail14486.d(97): Error: `nothrow` function `fail14486.test1b` may throw +fail_compilation/fail14486.d(73): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(74): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(75): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(76): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(77): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(74): Error: destructor `fail14486.C1b.~this` is not `nothrow` +fail_compilation/fail14486.d(75): Error: destructor `fail14486.C2b.~this` is not `nothrow` +fail_compilation/fail14486.d(76): Error: deallocator `fail14486.C3b.delete` is not `nothrow` +fail_compilation/fail14486.d(71): Error: `nothrow` function `fail14486.test1b` may throw --- */ void test1b() nothrow @@ -106,16 +80,21 @@ /* TEST_OUTPUT: --- -fail_compilation/fail14486.d(123): Error: `delete s0` is not `@safe` but is used in `@safe` function `test2a` -fail_compilation/fail14486.d(124): Error: `pure` function `fail14486.test2a` cannot call impure destructor `fail14486.S1a.~this` -fail_compilation/fail14486.d(124): Error: `@safe` function `fail14486.test2a` cannot call `@system` destructor `fail14486.S1a.~this` -fail_compilation/fail14486.d(124): Error: `@nogc` function `fail14486.test2a` cannot call non-@nogc destructor `fail14486.S1a.~this` -fail_compilation/fail14486.d(125): Error: `pure` function `fail14486.test2a` cannot call impure destructor `fail14486.S2a.~this` -fail_compilation/fail14486.d(125): Error: `@safe` function `fail14486.test2a` cannot call `@system` destructor `fail14486.S2a.~this` -fail_compilation/fail14486.d(125): Error: `@nogc` function `fail14486.test2a` cannot call non-@nogc destructor `fail14486.S2a.~this` -fail_compilation/fail14486.d(126): Error: `pure` function `fail14486.test2a` cannot call impure deallocator `fail14486.S3a.delete` -fail_compilation/fail14486.d(126): Error: `@safe` function `fail14486.test2a` cannot call `@system` deallocator `fail14486.S3a.delete` -fail_compilation/fail14486.d(126): Error: `@nogc` function `fail14486.test2a` cannot call non-@nogc deallocator `fail14486.S3a.delete` +fail_compilation/fail14486.d(102): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(102): Error: `delete s0` is not `@safe` but is used in `@safe` function `test2a` +fail_compilation/fail14486.d(103): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(103): Error: `pure` function `fail14486.test2a` cannot call impure destructor `fail14486.S1a.~this` +fail_compilation/fail14486.d(103): Error: `@safe` function `fail14486.test2a` cannot call `@system` destructor `fail14486.S1a.~this` +fail_compilation/fail14486.d(103): Error: `@nogc` function `fail14486.test2a` cannot call non-@nogc destructor `fail14486.S1a.~this` +fail_compilation/fail14486.d(104): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(104): Error: `pure` function `fail14486.test2a` cannot call impure destructor `fail14486.S2a.~this` +fail_compilation/fail14486.d(104): Error: `@safe` function `fail14486.test2a` cannot call `@system` destructor `fail14486.S2a.~this` +fail_compilation/fail14486.d(104): Error: `@nogc` function `fail14486.test2a` cannot call non-@nogc destructor `fail14486.S2a.~this` +fail_compilation/fail14486.d(105): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(105): Error: `pure` function `fail14486.test2a` cannot call impure deallocator `fail14486.S3a.delete` +fail_compilation/fail14486.d(105): Error: `@safe` function `fail14486.test2a` cannot call `@system` deallocator `fail14486.S3a.delete` +fail_compilation/fail14486.d(105): Error: `@nogc` function `fail14486.test2a` cannot call non-@nogc deallocator `fail14486.S3a.delete` +fail_compilation/fail14486.d(106): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. --- */ void test2a() @nogc pure @safe @@ -130,10 +109,15 @@ /* TEST_OUTPUT: --- -fail_compilation/fail14486.d(142): Error: destructor `fail14486.S1b.~this` is not `nothrow` -fail_compilation/fail14486.d(143): Error: destructor `fail14486.S2b.~this` is not `nothrow` -fail_compilation/fail14486.d(144): Error: deallocator `fail14486.S3b.delete` is not `nothrow` -fail_compilation/fail14486.d(139): Error: `nothrow` function `fail14486.test2b` may throw +fail_compilation/fail14486.d(125): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(126): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(127): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(128): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(129): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(126): Error: destructor `fail14486.S1b.~this` is not `nothrow` +fail_compilation/fail14486.d(127): Error: destructor `fail14486.S2b.~this` is not `nothrow` +fail_compilation/fail14486.d(128): Error: deallocator `fail14486.S3b.delete` is not `nothrow` +fail_compilation/fail14486.d(123): Error: `nothrow` function `fail14486.test2b` may throw --- */ void test2b() nothrow @@ -148,15 +132,20 @@ /* TEST_OUTPUT: --- -fail_compilation/fail14486.d(164): Error: `delete a0` is not `@safe` but is used in `@safe` function `test3a` -fail_compilation/fail14486.d(165): Error: `pure` function `fail14486.test3a` cannot call impure destructor `fail14486.S1a.~this` -fail_compilation/fail14486.d(165): Error: `@safe` function `fail14486.test3a` cannot call `@system` destructor `fail14486.S1a.~this` -fail_compilation/fail14486.d(165): Error: `@nogc` function `fail14486.test3a` cannot call non-@nogc destructor `fail14486.S1a.~this` -fail_compilation/fail14486.d(166): Error: `pure` function `fail14486.test3a` cannot call impure destructor `fail14486.S2a.~this` -fail_compilation/fail14486.d(166): Error: `@safe` function `fail14486.test3a` cannot call `@system` destructor `fail14486.S2a.~this` -fail_compilation/fail14486.d(166): Error: `@nogc` function `fail14486.test3a` cannot call non-@nogc destructor `fail14486.S2a.~this` -fail_compilation/fail14486.d(167): Error: `delete a3` is not `@safe` but is used in `@safe` function `test3a` -fail_compilation/fail14486.d(168): Error: `delete a4` is not `@safe` but is used in `@safe` function `test3a` +fail_compilation/fail14486.d(153): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(153): Error: `delete a0` is not `@safe` but is used in `@safe` function `test3a` +fail_compilation/fail14486.d(154): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(154): Error: `pure` function `fail14486.test3a` cannot call impure destructor `fail14486.S1a.~this` +fail_compilation/fail14486.d(154): Error: `@safe` function `fail14486.test3a` cannot call `@system` destructor `fail14486.S1a.~this` +fail_compilation/fail14486.d(154): Error: `@nogc` function `fail14486.test3a` cannot call non-@nogc destructor `fail14486.S1a.~this` +fail_compilation/fail14486.d(155): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(155): Error: `pure` function `fail14486.test3a` cannot call impure destructor `fail14486.S2a.~this` +fail_compilation/fail14486.d(155): Error: `@safe` function `fail14486.test3a` cannot call `@system` destructor `fail14486.S2a.~this` +fail_compilation/fail14486.d(155): Error: `@nogc` function `fail14486.test3a` cannot call non-@nogc destructor `fail14486.S2a.~this` +fail_compilation/fail14486.d(156): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(156): Error: `delete a3` is not `@safe` but is used in `@safe` function `test3a` +fail_compilation/fail14486.d(157): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(157): Error: `delete a4` is not `@safe` but is used in `@safe` function `test3a` --- */ void test3a() @nogc pure @safe @@ -171,9 +160,14 @@ /* TEST_OUTPUT: --- -fail_compilation/fail14486.d(182): Error: destructor `fail14486.S1b.~this` is not `nothrow` -fail_compilation/fail14486.d(183): Error: destructor `fail14486.S2b.~this` is not `nothrow` -fail_compilation/fail14486.d(179): Error: `nothrow` function `fail14486.test3b` may throw +fail_compilation/fail14486.d(175): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(176): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(177): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(178): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(179): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/fail14486.d(176): Error: destructor `fail14486.S1b.~this` is not `nothrow` +fail_compilation/fail14486.d(177): Error: destructor `fail14486.S2b.~this` is not `nothrow` +fail_compilation/fail14486.d(173): Error: `nothrow` function `fail14486.test3b` may throw --- */ void test3b() nothrow diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/fail_compilation/fail2361.d new/dmd-2.079.1/test/fail_compilation/fail2361.d --- old/dmd-2.079.0/test/fail_compilation/fail2361.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/test/fail_compilation/fail2361.d 2018-04-14 18:11:03.000000000 +0200 @@ -1,7 +1,7 @@ /* TEST_OUTPUT: --- -fail_compilation/fail2361.d(14): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. +fail_compilation/fail2361.d(14): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. fail_compilation/fail2361.d(14): Error: cannot modify `immutable` expression `c` --- */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/fail_compilation/fail_arrayop2.d new/dmd-2.079.1/test/fail_compilation/fail_arrayop2.d --- old/dmd-2.079.0/test/fail_compilation/fail_arrayop2.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/test/fail_compilation/fail_arrayop2.d 2018-04-14 18:11:03.000000000 +0200 @@ -1,9 +1,9 @@ // REQUIRED_ARGS: -o- + /* TEST_OUTPUT: --- -fail_compilation/fail_arrayop2.d(281): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. fail_compilation/fail_arrayop2.d(13): Error: array operation `[1, 2, 3] - [1, 2, 3]` without destination memory not allowed fail_compilation/fail_arrayop2.d(16): Error: invalid array operation `"a" - "b"` (possible missing []) --- @@ -198,9 +198,9 @@ /* TEST_OUTPUT: --- -fail_compilation/fail_arrayop2.d(246): Error: array operation `[1] * 6` without destination memory not allowed fail_compilation/fail_arrayop2.d(247): Error: array operation `[1] * 6` without destination memory not allowed fail_compilation/fail_arrayop2.d(248): Error: array operation `[1] * 6` without destination memory not allowed +fail_compilation/fail_arrayop2.d(249): Error: array operation `[1] * 6` without destination memory not allowed fail_compilation/fail_arrayop2.d(253): Error: array operation `[1] * 6` without destination memory not allowed fail_compilation/fail_arrayop2.d(256): Error: array operation `[1] * 6` without destination memory not allowed fail_compilation/fail_arrayop2.d(265): Error: array operation `[1] * 6` without destination memory not allowed @@ -209,6 +209,7 @@ fail_compilation/fail_arrayop2.d(272): Error: array operation `[1] * 6` without destination memory not allowed fail_compilation/fail_arrayop2.d(275): Error: `([1] * 6)[0..2]` is not an lvalue fail_compilation/fail_arrayop2.d(278): Error: can only `*` a pointer, not a `int[]` +fail_compilation/fail_arrayop2.d(281): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. fail_compilation/fail_arrayop2.d(281): Error: `[1] * 6` is not an lvalue fail_compilation/fail_arrayop2.d(284): Error: array operation `da[] * 6` without destination memory not allowed fail_compilation/fail_arrayop2.d(287): Error: array operation `da[] * 6` without destination memory not allowed @@ -248,7 +249,6 @@ [1] * 6]; } // AssocArrayLiteralExp //TupleExp - // StructLiteralExp.elements <- preFunctionParameters in CallExp { auto r = S([1] * 6); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/fail_compilation/faildeleteaa.d new/dmd-2.079.1/test/fail_compilation/faildeleteaa.d --- old/dmd-2.079.0/test/fail_compilation/faildeleteaa.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/test/fail_compilation/faildeleteaa.d 2018-04-14 18:11:03.000000000 +0200 @@ -1,7 +1,7 @@ /* TEST_OUTPUT: --- -fail_compilation/faildeleteaa.d(12): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. +fail_compilation/faildeleteaa.d(12): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. fail_compilation/faildeleteaa.d(12): Error: cannot delete type `int` --- */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/fail_compilation/nogc1.d new/dmd-2.079.1/test/fail_compilation/nogc1.d --- old/dmd-2.079.0/test/fail_compilation/nogc1.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/test/fail_compilation/nogc1.d 2018-04-14 18:11:03.000000000 +0200 @@ -1,15 +1,6 @@ // REQUIRED_ARGS: -o- // PERMUTE_ARGS: -/* -TEST_OUTPUT: ---- -fail_compilation/nogc1.d(91): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/nogc1.d(92): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. -fail_compilation/nogc1.d(93): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. ---- -*/ - /***************** NewExp *******************/ struct S1 { } @@ -21,14 +12,14 @@ /* TEST_OUTPUT: --- -fail_compilation/nogc1.d(36): Error: cannot use `new` in `@nogc` function `nogc1.testNew` +fail_compilation/nogc1.d(27): Error: cannot use `new` in `@nogc` function `nogc1.testNew` +fail_compilation/nogc1.d(29): Error: cannot use `new` in `@nogc` function `nogc1.testNew` +fail_compilation/nogc1.d(30): Error: cannot use `new` in `@nogc` function `nogc1.testNew` +fail_compilation/nogc1.d(32): Error: cannot use `new` in `@nogc` function `nogc1.testNew` +fail_compilation/nogc1.d(33): Error: `@nogc` function `nogc1.testNew` cannot call non-@nogc constructor `nogc1.S2.this` +fail_compilation/nogc1.d(34): Error: cannot use `new` in `@nogc` function `nogc1.testNew` +fail_compilation/nogc1.d(35): Error: `@nogc` function `nogc1.testNew` cannot call non-@nogc allocator `nogc1.S4.new` fail_compilation/nogc1.d(38): Error: cannot use `new` in `@nogc` function `nogc1.testNew` -fail_compilation/nogc1.d(39): Error: cannot use `new` in `@nogc` function `nogc1.testNew` -fail_compilation/nogc1.d(41): Error: cannot use `new` in `@nogc` function `nogc1.testNew` -fail_compilation/nogc1.d(42): Error: `@nogc` function `nogc1.testNew` cannot call non-@nogc constructor `nogc1.S2.this` -fail_compilation/nogc1.d(43): Error: cannot use `new` in `@nogc` function `nogc1.testNew` -fail_compilation/nogc1.d(44): Error: `@nogc` function `nogc1.testNew` cannot call non-@nogc allocator `nogc1.S4.new` -fail_compilation/nogc1.d(47): Error: cannot use `new` in `@nogc` function `nogc1.testNew` --- */ @nogc void testNew() @@ -50,13 +41,13 @@ /* TEST_OUTPUT: --- -fail_compilation/nogc1.d(64): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` -fail_compilation/nogc1.d(66): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` -fail_compilation/nogc1.d(67): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` -fail_compilation/nogc1.d(69): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` -fail_compilation/nogc1.d(70): Error: `@nogc` function `nogc1.testNewScope` cannot call non-@nogc constructor `nogc1.S2.this` -fail_compilation/nogc1.d(71): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` -fail_compilation/nogc1.d(72): Error: `@nogc` function `nogc1.testNewScope` cannot call non-@nogc allocator `nogc1.S4.new` +fail_compilation/nogc1.d(55): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` +fail_compilation/nogc1.d(57): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` +fail_compilation/nogc1.d(58): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` +fail_compilation/nogc1.d(60): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` +fail_compilation/nogc1.d(61): Error: `@nogc` function `nogc1.testNewScope` cannot call non-@nogc constructor `nogc1.S2.this` +fail_compilation/nogc1.d(62): Error: cannot use `new` in `@nogc` function `nogc1.testNewScope` +fail_compilation/nogc1.d(63): Error: `@nogc` function `nogc1.testNewScope` cannot call non-@nogc allocator `nogc1.S4.new` --- */ @nogc void testNewScope() @@ -81,9 +72,12 @@ /* TEST_OUTPUT: --- -fail_compilation/nogc1.d(91): Error: cannot use `delete` in `@nogc` function `nogc1.testDelete` -fail_compilation/nogc1.d(92): Error: cannot use `delete` in `@nogc` function `nogc1.testDelete` -fail_compilation/nogc1.d(93): Error: cannot use `delete` in `@nogc` function `nogc1.testDelete` +fail_compilation/nogc1.d(85): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/nogc1.d(85): Error: cannot use `delete` in `@nogc` function `nogc1.testDelete` +fail_compilation/nogc1.d(86): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/nogc1.d(86): Error: cannot use `delete` in `@nogc` function `nogc1.testDelete` +fail_compilation/nogc1.d(87): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. +fail_compilation/nogc1.d(87): Error: cannot use `delete` in `@nogc` function `nogc1.testDelete` --- */ @nogc void testDelete(int* p, Object o, S1* s) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/dmd-2.079.0/test/fail_compilation/test16195.d new/dmd-2.079.1/test/fail_compilation/test16195.d --- old/dmd-2.079.0/test/fail_compilation/test16195.d 2018-03-02 18:42:36.000000000 +0100 +++ new/dmd-2.079.1/test/fail_compilation/test16195.d 2018-04-14 18:11:03.000000000 +0200 @@ -1,7 +1,7 @@ /* * TEST_OUTPUT: --- -fail_compilation/test16195.d(14): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` instead. +fail_compilation/test16195.d(14): Deprecation: The `delete` keyword has been deprecated. Use `object.destroy()` (and `core.memory.GC.free()` if applicable) instead. fail_compilation/test16195.d(14): Error: `delete p` is not `@safe` but is used in `@safe` function `test` --- */ ++++++ druntime-2.079.0.tar.gz -> druntime-2.079.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/druntime-2.079.0/changelog/core-memory-__delete.dd new/druntime-2.079.1/changelog/core-memory-__delete.dd --- old/druntime-2.079.0/changelog/core-memory-__delete.dd 2018-03-02 18:25:33.000000000 +0100 +++ new/druntime-2.079.1/changelog/core-memory-__delete.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,35 +0,0 @@ -`core.memory.__delete` has been added - -$(REF __delete, core, memory) allows easy migration from the deprecated `delete`. -`__delete` behaves exactly like `delete`: - ---- -bool dtorCalled; -class B -{ - int test; - ~this() - { - dtorCalled = true; - } -} -B b = new B(); -B a = b; -b.test = 10; - -__delete(b); -assert(b is null); -assert(dtorCalled); -// but be careful, a still points to it -assert(a !is null); ---- - -For example, on a Posix platform you can simply run: - -$(CONSOLE -sed "s/delete \(.*\);/__delete(\1);/" -i **/*.d -) - -Users should prefer $(REF destroy, object)` to explicitly finalize objects, -and only resort to $(REF __delete, core,memory) when $(REF destroy, object) -would not be a feasible option. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/druntime-2.079.0/changelog/lazy-gc-init.dd new/druntime-2.079.1/changelog/lazy-gc-init.dd --- old/druntime-2.079.0/changelog/lazy-gc-init.dd 2018-03-02 18:25:33.000000000 +0100 +++ new/druntime-2.079.1/changelog/lazy-gc-init.dd 1970-01-01 01:00:00.000000000 +0100 @@ -1,3 +0,0 @@ -The garbage collector is now lazily initialized on first use - -The runtime now lazily initializes the GC on first use, thus allowing applications that do not use the GC to skip its initialization. ++++++ phobos-2.079.0.tar.gz -> phobos-2.079.1.tar.gz ++++++ ++++ 2802 lines of diff (skipped)
