• d-bugmail puremagic.com (49/49) Dec 12 2023 https://issues.dlang.org/show_bug.cgi?id=24279

d-bugmail puremagic.com writes:

https://issues.dlang.org/show_bug.cgi?id=24279

          Issue ID: 24279
           Summary: Conflicting constructors/functions due to default
                    arguments should not compile
           Product: D
           Version: D2
          Hardware: x86
                OS: Windows
            Status: NEW
          Severity: normal
          Priority: P1
         Component: dmd
          Assignee: nobody puremagic.com
          Reporter: HuskyNator protonmail.ch

When constructors or functions conflict due to having the same calling
signature, they should not be allowed to compile.

This is already the case in most scenarios, but when default arguments cause
conflict, the compiler does not catch this issue. Even more so, in the case of
constructors, visibility rules are ignored.

Example:
```d
module text;
import std.stdio;
class Text {
        string text;
        private this(string text) {
                writeln("private");
        }
        this(string filename, string arg2 = ".txt") {
                writeln("public");
        }
}
```
```d
module app;
void main(){
    Text t = new Text("file"); // writes "private"
}
```

Calling `new Text("test")` from anywhere will call the first constructor,
ignoring its `private` attribute.

If this is done with functions instead of constructors, the same thing will
happen with one exception: the compiler will state the function is not
accessible. (It will however try to resolve to the private function, ignoring
the accessible alternative)

1. This hints at issues with constructors ignoring visibility attributes!
2. The code should not compile when conflicts occur (even when this is due to
default values).

--