currently, code like the following is rejected: abstract class C{ int foo(int x) in{assert(x<0);} out(result){assert(result>0);} } tt.d(10): Error: function tt.C.foo in and out contracts require function body. Which does not make sense, because contracts logically belong to the method declaration. Such code should be accepted and the contracts should be subject to contract inheritance. This will require a tiny grammar change.
I would like a clarification about abstract class/methods with contracts. Should the bottom two examples be valid D code? ---- // Works ( and documented TDPL/website ) interface I { int func( int x ) in { assert(x == 0); } } class C : I { int func( int x ) { return x; } } // Does not work ( undocumented ) abstract class A { int func( int x ) in { assert(x == 0); } } // ditto class A2 { abstract int func( int x ) in { assert(x == 0); } }
Yes, that is the plan.
Is there any news on this? Design-by-contract in D is seriously crippled due to this bug.
(In reply to comment #3) > Is there any news on this? Design-by-contract in D is seriously crippled due to > this bug. It's an arbitrary restriction, not a bug. http://www.dlang.org/declaration.html Decl: StorageClasses Decl BasicType Declarators ; BasicType Declarator FunctionBody AutoDeclaration http://www.dlang.org/function.html FunctionBody: BlockStatement BodyStatement InStatement BodyStatement OutStatement BodyStatement InStatement OutStatement BodyStatement OutStatement InStatement BodyStatement InStatement and OutStatement are part of FunctionBody, so if the function has no body then it can't have in and out contracts. But I entirely agree that it should be allowed. Contracts are part of the API, not the implementation. As such, they are equally applicable to abstract/interface methods. It could also improve contract checking in closed-source libraries.
Possible grammar rewrite: Decl: StorageClasses Decl BasicType Declarators ; BasicType Declarator BlockStatement BasicType Declarator BodyStatement BasicType Declarator Contracts ; BasicType Declarator Contracts BodyStatement AutoDeclaration Contracts: InStatement OutStatement InStatement OutStatement OutStatement InStatement
https://github.com/D-Programming-Language/dmd/pull/2281
amen, this should DEFINITELY work. without it, we can't have contracts in .di generation nor in interfaces, making them really hard to use as intended. This is a bigger problem to me than the lack of preconditions. Ugh.
well I guess we *can* have interfaces now, but not abstract classes... random limitation indeed.
Seconding this issue.
Commits pushed to master at https://github.com/dlang/dmd https://github.com/dlang/dmd/commit/c7d0672b7faa21ead0edd8924c2a719aca94fc21 fix issue 6549 - Implement contracts without implementation https://github.com/dlang/dmd/commit/d511b9579559d7f3109a7a6aef05b80786612f49 Merge pull request #7527 from ibuclaw/issue6549 fix issue 6549 - Implement contracts without implementation
dlang/dmd pull request #12106 "[dmd-cxx] Implement new syntax for contracts and invariants" was merged into dmd-cxx: - edaf335e4d3c7f9100aed809dca584aa8da2d713 by Iain Buclaw: [dmd-cxx] fix issue 6549 - Implement contracts without implementation https://github.com/dlang/dmd/pull/12106