Note: This post has been updated on 8/29/2016 with new information on mixin template imports.
In the upcoming version of D, several changes have been made to the import system, including fixes for 2 of the oldest bugs in D history.
There’s bound to be a lot of confusion on this, so I wrote this to try and explain the rules, and the reasoning behind some of the changes. I’ll also explain how you can mitigate any issues you have in your code base.
Bugs 313 and 314
Private imports are not supposed to infiltrate the modules they are imported in. If you import
b privately, then you should not have any access to
b‘s symbols. However, before this was fixed, you could access
b symbols via the Fully Qualified Name. A FQN is where you list all packages, including subpackages, separated by dots, to access a symbol. For example
In addition, when importing a module using static, renamed, or selective imports, the imported symbols were incorrectly made public to importing modules.
With 2.070 and prior versions, compiling this works just fine. With 2.071 and above, you will get either a deprecation warning, or an error.
Note that the
private qualifier is only for illustration. This is the default import protection for any imports.
For an example of how selective imports add public symbols:
With 2.070, this compiled just fine. However,
printf is supposed to be a private symbol of module
ex2_a. With 2.071 and above, this will trigger a deprecation warning. In the future, the code will trigger an error.
Selective imports and FQN
A combination of both 313 and 314 is when you use a selective import, and expect the Fully Qualified Name to also be imported. This is not what the selective import was supposed to do, it was only supposed to add the symbols requested.
In this example,
std.stdio.writeln is not actually supposed to be imported, only
write is supposed to be imported (and even the FQN
std.stdio.write isn’t imported!). We have to import
std.range, because otherwise this would not compile (ironically, the package
std is not imported by the selective import unless there is another import of the FQN).
In 2.070, this produces no warning or error. In 2.071 and beyond, this will produce a deprecation warning, and eventually an error.
Fixing problematic code
In order to fix such code, you have to decide what was intended. If your code really was supposed to publicly import the symbols, prepend
public to the import statement. This brings all the symbols imported into the namespace of the module, so any importing module also sees those symbols. In our example 2 above, this would mean adding
public to the import statement in ex2_a.d
If the imported module was not supposed to publicly expose the symbols, then you need to fix all importing modules with this problem. In our example, this would mean adding
import core.stdc.stdio; to the top of ex2_main.d.
In the case of accidentally exposing the FQN of symbols that were privately imported, this is typically an issue with the importing module, not the imported one. In this case, you need to add an import. In our example 1 case, this would mean adding an import for
ex1_a module to ex1_main.d.
For example 3, you can achieve the original behavior by both selectively importing the symbol, and statically importing the module. Just add
static import std.stdio; to your scoped imports. Alternatively, you can add
writeln to the selectively imported symbols, and use the unqualified name instead of the FQN.
For an example of how Phobos was fixed for this problem (there were thousands of messages in every build with deprecation warnings), see the PR I created.
Another import-related bug fix is to prevent unintentional hijacking of symbols inside a scoped import. Such imports are not at module level, and import inside a function or other scope. These imports are only valid within the scope. Prior to 2.071, such imports were equivalent to importing every symbol in the imported module into the namespace of that scope. This overrode any other symbol in that namespace, including local variables in outer scopes. An example:
In 2.070 and prior, the assert above used
ex4_a‘s definition of
foo, not the local variable. In 2.071 and beyond, the local
foo has precedence. The precedence rules work like this:
- Any local symbols are examined first. This includes selective imports which are aliased into the local scope.
- Any module-level symbols are examined.
- Any symbols imported are examined, starting with the most derived scope imports, all the way to module-level imports.
Note that this may be a breaking change, as demonstrated by the example.
Why did we change this?
This was changed because any symbol added to an import can drastically affect any code that uses non-selective scoped imports, hijacking the symbol in ways that the author cannot predict. While there is still potential for hijacking, since scoped imports override any module-level or higher level scoped imports, at least symbols that are locally defined are not affected. These are the symbols under direct control of the author of the module, and they should always have precedence.
A common change to a module is to move imports inside the scope of functions or types that are the only users of that import. This helps avoid namespace pollution. However, given that local module functions had precedence over imported ones, but scoped imports would take precedence away, this move was not always what the user intended. For this reason, module functions now always have precedence over non-selective scoped imports.
Fixing problematic code
This one is a little more nuanced. It may be that you wished to override the local symbols! In this case, use a selective import. Selective imports alias the symbols selected into the local scope, overriding any other symbols defined at that point. In our example, if we expected
foo to refer to
ex4_a.foo, then we would use an import like this:
import ex4_a: foo;
In addition, you can use the FQN instead of using the simple name. I would recommend using a static or renamed import in that case.
Imports from mixin templates ((Thanks to captaindet for bringing this issue to my attention))
A somewhat controversial change with 2.071 is the effect mixins can have with imports. If you have a mixin template which imports a module, then use that template within a class or struct, the import is only considered while inside the mixin template. It is not considered when inside the class or struct. For example:
The previous version would allow the import to be considered where the mixin occurs. In order to have a mixin template add an imported symbol, you can selectively import the symbol. In this case, static import will not work:
Why did we change this?
The explanation seems to be that allowing such imports can create a form of hijacking. Since a class-level import would override a module-level import, a user may not realize that the mixed-in import is present, and therefore overriding a module-level import that is in the local module. The hijacking can come after the fact, in the imported module, without the user’s knowledge or any changes in his code.
Fixing problematic code
There isn’t a very easy way to rectify this problem. The only solution is to selectively import all the symbols you may need from that other module within the mixin.
The new version of the compiler comes with two new transitional switches that you can use to find or ignore these errors (note that these affect the mixin template imports as well):
-transition=checkimports: This switch will warn you if you have code that behaved differently prior to issue 10378 being fixed. Note that this may slow down compilation notably, hence it’s not the default ((Thanks to Dicebot for pointing this out))
-transition=import: This switch reverts behavior back to the import rules prior to 10378 being fixed. Only use this switch as a stop-gap measure until you can fix the code!
Because importing external modules that are outside your control can lead to hijacking, I recommend never importing a module at a scoped level that isn’t selective, static, or renamed. This gives you full control over what invades your namespace. The compiler will protect you now a little bit better, but it’s always better to defend against namespace pollution from an uncontrolled module.