www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - cast overly permissive with extern(C++ ) classes;

reply Timothee Cour <thelastmammoth gmail.com> writes:
should we force force casting through `void*` for extern(C++) classes ?
i.e. `cast(Derived) cast(void*) base_instance;`

currently, `cast(A) unrelad_cpp_instance` happily compiles but
shouldn't, it's very error prone even though the cast syntax suggests
type safety; especially a problem if we make a class become
extern(C++) in the future

[came up after discussing with jacob-carlborg]
Feb 06
parent reply timotheecour <timothee.cour2 gmail.com> writes:
On Tuesday, 6 February 2018 at 20:39:09 UTC, Timothee Cour wrote:
 should we force force casting through `void*` for extern(C++) 
 classes ?
 i.e. `cast(Derived) cast(void*) base_instance;`

 currently, `cast(A) unrelad_cpp_instance` happily compiles but 
 shouldn't, it's very error prone even though the cast syntax 
 suggests type safety; especially a problem if we make a class 
 become extern(C++) in the future

 [came up after discussing with jacob-carlborg]
https://run.dlang.io/?compiler=dmd&source=import%20std.stdio;%0Aclass%20Foo%20%7B%7D%0A%0Avoid%20main()%0A%7B%0A%09auto%20f%20%3D%20new%20const%20Foo;%0A%20%20%20%20pragma(msg,%20typeof(cast(Foo)%20f));%0A%7D ``` import std.stdio; extern(C++){ class Base {void ignore(){}} class Derived : Base {} class C {} } void main() { Base f = new Derived; auto temp=cast(C)f; writeln(temp is null); // false, which is not good } ```
Feb 06
parent reply timotheecour <timothee.cour2 gmail.com> writes:
On Tuesday, 6 February 2018 at 21:13:50 UTC, timotheecour wrote:
 On Tuesday, 6 February 2018 at 20:39:09 UTC, Timothee Cour 
 wrote:
 should we force force casting through `void*` for extern(C++) 
 classes ?
 i.e. `cast(Derived) cast(void*) base_instance;`

 currently, `cast(A) unrelad_cpp_instance` happily compiles but 
 shouldn't, it's very error prone even though the cast syntax 
 suggests type safety; especially a problem if we make a class 
 become extern(C++) in the future

 [came up after discussing with jacob-carlborg]
Actually how about introducing a library solution for explicit casting: * works with UFCS chains (unlike cast) * DSL is very intuitive, readable and extensible ``` foo.Cast!"+immutable,dynamic" myint.cast!"-const,"unsigned" ``` meaning: +immutable: make immutable; -const: remove const storage class if was const; dynamic: only allow dynamic cast (cf avoids above bug); unsigned: cast integer to unsigned; other keywords could be trivially added to DSL alternative is not DRY (eg: `Foo foo; cast(const(Foo)) foo;` ; not typesafe/expressive: (cast(Foo)foo) will remove const-ness in foo even though just a dynamic cast was intended for eg; and doesn't work in UFCS chains (requires lots of parenthesis)
Feb 06
parent reply Seb <seb wilzba.ch> writes:
On Tuesday, 6 February 2018 at 21:34:07 UTC, timotheecour wrote:
 On Tuesday, 6 February 2018 at 21:13:50 UTC, timotheecour wrote:
[...]
Actually how about introducing a library solution for explicit casting: * works with UFCS chains (unlike cast) * DSL is very intuitive, readable and extensible [...]
Like assumeUnique? https://dlang.org/library/std/exception/assume_unique.html
Feb 06
parent reply Timothee Cour <thelastmammoth gmail.com> writes:
 Like assumeUnique?
https://dlang.org/library/std/exception/assume_unique.html what do you mean? u mean adding "unique" to the DSL list ? maybe! * for cast on extern C++ classes, why not use the same logic as what C++ uses for dynamic_cast? (simplified because we don't support multople inheritance) On Tue, Feb 6, 2018 at 2:54 PM, Seb via Digitalmars-d <digitalmars-d puremagic.com> wrote:
 On Tuesday, 6 February 2018 at 21:34:07 UTC, timotheecour wrote:
 On Tuesday, 6 February 2018 at 21:13:50 UTC, timotheecour wrote:
 [...]
Actually how about introducing a library solution for explicit casting: * works with UFCS chains (unlike cast) * DSL is very intuitive, readable and extensible [...]
Like assumeUnique? https://dlang.org/library/std/exception/assume_unique.html
Feb 06
parent reply Seb <seb wilzba.ch> writes:
On Tuesday, 6 February 2018 at 23:15:07 UTC, Timothee Cour wrote:
 Like assumeUnique?
https://dlang.org/library/std/exception/assume_unique.html what do you mean? u mean adding "unique" to the DSL list ? maybe!
You asked: Actually how about introducing a library solution for explicit casting. That's why I thought about the existing assumeUnique: ``` immutable(T)[] assumeUnique(T)(ref T[] array) pure nothrow { auto result = cast(immutable(T)[]) array; array = null; return result; } ``` https://github.com/dlang/phobos/blob/v2.078.1/std/exception.d#L905
Feb 06
next sibling parent Timothee Cour <thelastmammoth gmail.com> writes:
assumeUnique has a very specific use case; i was describing a more
general way to handle various types of cast (and be explicit about
whats allowed) as mentioned above

On Tue, Feb 6, 2018 at 3:18 PM, Seb via Digitalmars-d
<digitalmars-d puremagic.com> wrote:
 On Tuesday, 6 February 2018 at 23:15:07 UTC, Timothee Cour wrote:
 Like assumeUnique?
https://dlang.org/library/std/exception/assume_unique.html what do you mean? u mean adding "unique" to the DSL list ? maybe!
You asked: Actually how about introducing a library solution for explicit casting. That's why I thought about the existing assumeUnique: ``` immutable(T)[] assumeUnique(T)(ref T[] array) pure nothrow { auto result = cast(immutable(T)[]) array; array = null; return result; } ``` https://github.com/dlang/phobos/blob/v2.078.1/std/exception.d#L905
Feb 06
prev sibling parent reply Timothee Cour <thelastmammoth gmail.com> writes:
but yes, API would look similar:

auto Cast(T)(T a) if(...) {}
auto Cast(string dsl)(T a) {}

On Tue, Feb 6, 2018 at 3:31 PM, Timothee Cour <thelastmammoth gmail.com> wrote:
 assumeUnique has a very specific use case; i was describing a more
 general way to handle various types of cast (and be explicit about
 whats allowed) as mentioned above

 On Tue, Feb 6, 2018 at 3:18 PM, Seb via Digitalmars-d
 <digitalmars-d puremagic.com> wrote:
 On Tuesday, 6 February 2018 at 23:15:07 UTC, Timothee Cour wrote:
 Like assumeUnique?
https://dlang.org/library/std/exception/assume_unique.html what do you mean? u mean adding "unique" to the DSL list ? maybe!
You asked: Actually how about introducing a library solution for explicit casting. That's why I thought about the existing assumeUnique: ``` immutable(T)[] assumeUnique(T)(ref T[] array) pure nothrow { auto result = cast(immutable(T)[]) array; array = null; return result; } ``` https://github.com/dlang/phobos/blob/v2.078.1/std/exception.d#L905
Feb 06
parent reply Seb <seb wilzba.ch> writes:
On Tuesday, 6 February 2018 at 23:32:49 UTC, Timothee Cour wrote:
 but yes, API would look similar:

 auto Cast(T)(T a) if(...) {}
 auto Cast(string dsl)(T a) {}
Ah I see. I think this is already partially done in Phobos (which shows the usefulness): https://github.com/dlang/phobos/blob/master/std/experimental/typecons.d#L37
Feb 06
parent Timothee Cour <thelastmammoth gmail.com> writes:
ugh... dynamicCast is private...

On Tue, Feb 6, 2018 at 5:13 PM, Seb via Digitalmars-d
<digitalmars-d puremagic.com> wrote:
 On Tuesday, 6 February 2018 at 23:32:49 UTC, Timothee Cour wrote:
 but yes, API would look similar:

 auto Cast(T)(T a) if(...) {}
 auto Cast(string dsl)(T a) {}
Ah I see. I think this is already partially done in Phobos (which shows the usefulness): https://github.com/dlang/phobos/blob/master/std/experimental/typecons.d#L37
Feb 06