Change Log: 2.071.0

It is no longer possible to bypass private imports by using fully qualified names, e.g. the following example will fail with package std.range is not accessible here.

import std.algorithm;

static assert(std.range.isForwardRange!string);

To ease updating existing code, the old behavior was retained but deprecated.

It is no longer possible to use private selective or renamed imports in another module, e.g. the following example will fail with a.File is not visible from module b.

module a;
import std.stdio : File; // imports are private by default

module b;
import a;

File f; // File is private

To ease updating existing code, the old behavior was retained but deprecated. This fix relies on the visibility changes introduced with DIP22.

These changes were made to the name lookup algorithm:

1. Lookup for unqualified names is change from one pass to two pass. The first pass goes through the scopes but does not check import declarations. If not found, the second pass goes through the scopes and only looks at import declarations.
2. Qualified name lookups, base class lookups, and WithStatement lookups no longer search import declarations, unless a module is the subject of the lookup, where the behavior remains as before.

This can break existing code, although reliance on the previous behavior tends to be unintended, and fixing it improves the comprehensibility of the code. Breakage tends to take the form of a symbol now being flagged as undefined. Fixing the breakage can be done by fully qualifying the name, or adding an alias to the import declaration.

The old lookup behavior can be restored using the -transition=import compiler switch. With -transition=checkimports the compiler will issue deprecation warnings when the old and new lookup find different symbols. You can combine both switches to use the old lookup and still get deprecation warnings.

See also Bugzilla 10378

Protection (private, package, protected) is now already enforced during symbol lookup in order to resolve any conflicts between private and public symbols that could occur with the old access check scheme.

The visibility of overloaded symbols with mixed protection is determined by the most visibile member, but additional access check against the exact symbol is performed after overload resolution.

To ease updating existing code, a deprecated search for invisible symbols will be performed. For the the old lookup behavior (using the -transition=import or -transition=checkimports compiler switch) symbol visibility is ignored. All existing access checks remain active during the deprecation phase.

See also DIP22

Manifest constants (enum, static immutable) can now be used for deprecation message, as well as concatenated strings.

Example:

string generateMessage() { return "Some deprecation message"; }
enum DepMsg = generateMessage();

deprecated(DepMsg) class Foo {}
deprecated("Some long deprecation " ~ "message") class Bar {}

One can now use aa.clear() to remove all elements from an associative array. This allows removing all elements from all references to the same array (setting to null just reset the reference, but did not removed the elements from other references).

auto aa = ["first" : "entry", "second": "entry"];
auto aa2 = aa1; // reference to the same AA
aa.clear(); // still retains its current capacity for faster imports
assert(aa2.length == 0); // other references affected

This results in a 5% faster GC on average, with the most benefits going to multi-threaded programs that use the GC. See druntime#1447 for more details.

nextPow2 and truncPow2 are functions for rounding numbers to powers of two.

import std.math;

assert(nextPow2(10) == 16);
assert(nextPow2(4000) == 4096);

assert(truncPow2(10) == 8);
assert(truncPow2(4000) == 2048);

startsWith and endsWith can now be used just with a predicate.

import std.algorithm.searching;
import std.ascii : isAlpha;

assert("abc".endsWith!isAlpha);
assert(!"ab1".endsWith!(a => a.isAlpha));

assert("abc".startsWith!isAlpha);
assert(!"1ab".startsWith!isAlpha);

Previous to this addition, in order to get the number of the greatest elements, you had to use minCount!"a > b", which was very confusing. This change adds convenience functions to fix this issue.