On 12/6/17 2:19 PM, A Guy With a Question wrote:
On Wednesday, 6 December 2017 at 18:09:45 UTC, Steven Schveighoffer wrote:
On 12/6/17 12:17 PM, Steven Schveighoffer wrote:
So why wouldn't the compiler fail? Because it has no idea yet what
you mean by Nullable. It doesn't even know if Nullable will be
available or not. You could even import Nullable, but Nullable!T may
be an error.
To give an example of why the compiler waits until instantiation:
class C(T) : T
{
void foo() { doesthisexist(); }
}
class D { void doesthisexist(); }
auto x = new C!D; // OK
auto y = new C!Object: // fail
-Steve
It also doesn't parse or do semantic checks on unit tests unless you add
the flag...apparently.
This compiles...
unittest
{
WHY DOESNT THE COMPILER FIND A PROBLEM HERE!?
}
It seems D's fast compile times are achieved by skipping semantic
checking and even parsing when it doesn't feel it's needed.
This is a red herring. The compile times are fast even with unittests
enabled. They are just faster (and use less memory) when unittests
aren't compiled in.
If a unit test is instantiating tons of templates that I'm not using in
my main code, I don't want that being compiled and then thrown away when
I don't care about it!
I strongly
disagree with this decision. This could leave complex dormant time bombs
that break builds unexpectedly and even accidentally.
This decision was made by reality. How do you compile incomplete code?
that is essentially what a template is.
In terms of unit tests that don't compile, I can't ever imagine someone
writing a unittest and then not compiling with -unittest, and being
upset their code "passed".
Note, this was done pretty recently, and simply to make the compiler
consume less memory (and run a bit faster).
It's
understandable in certain situations where there is enough information,
but the first step to testing code, is first making sure it compiles...I
don't want the compiler making decisions on what is worthy to compile.
The first step to testing code is writing tests. And the idea that the
compiler is making these decisions arbitrarily is incorrect. You are
telling the compiler how to compile.
If I pass a d source file into it, I want to know if it's valid. This is
unfortunate. This might be a deal breaker for me.
There is literally only one exception to the rule, unittests. Everything
else must be valid syntax-wise.
Even version statements must have valid syntax inside them.
Hardly a deal-breaker, since you aren't going to write unittests and
then not run them.
-Steve
