DIP 1009--Improve Contract Usability--Preliminary Review Round 1

[via Digitalmars-d]

On Thursday, 29 June 2017 at 01:37:17 UTC, H. S. Teoh wrote:
> On Thu, Jun 29, 2017 at 01:22:31AM +0000, Mark via 
> Digitalmars-d wrote: [...]
>> So basically, I'd like the ability to implement fairly simple 
>> contracts (with a similar level of sophistication to the above 
>> examples) that the compiler can check for me. I don't know, 
>> maybe this is easier to implement using UDAs...
>
> One idea I have is that the compiler could recognize certain 
> straightforward contracts (like int < value) and use VRP (value 
> range propagation) to detect cases where it's clear that the 
> contract would be violated.
>
> However, this can only be done in a very rudimentary fashion, 
> because:
>
> (1) DbC contracts pertain to *runtime* argument values, so while
> checking for simple cases at compile-time is nice, it isn't 
> really in
> the charter of (D's implementation of) DbC.
>
> (2) VRP in the compiler currently only works within a very 
> limited
> scope, IIRC within a single expression. So while it may detect 
> the
> `foo(bar())` case, it probably won't detect the `x=bar(); 
> foo(x);` case.
> Ostensibly the scope of VRP ought to be expanded, however:
>
> (3) In the past Walter has shown some reluctance in adding 
> features that hurt compilation time; if a more sophisticated 
> implementation of VRP is required and it's deemed too expensive 
> in terms of compilation time, Walter may veto it.
>
> (4) Arbitrarily complex boolean conditions are undecidable in 
> general, so unless you have a way to solve the halting problem, 
> a general solution is intractible.  Of course, the kind of 
> conditions you find in contracts generally ought to be nowhere 
> near the halting problem in complexity, but it's not clear how 
> far one can go without running the risk of (3).  My guess is 
> that something based on VRP is the most likely to materialize 
> in the foreseeable future.
>
>
> T

https://github.com/dlang/dmd/pull/3799