Casting to interface not allowed in @safe code?

Hi, consider this: interface Base { void setup(); } interface FeatureX { void x(); } class Foo: Base, FeatureX { void setup(){}; void x(){}; } void main() { Base foo = new Foo(); // This would be the result of a factory class (cast(FeatureX)foo).x(); // 1 } 1) error: casting to interface FeatureX is not allowed in @safe code. Question: How to call foo.x in @safe code ?

On Tue, May 21, 2019 at 7:55 AM Jim via Digitalmars-d-learn < digitalmars-d-learn@puremagic.com> wrote: > Hi, > > Question: How to call foo.x in @safe code ? > @safe: interface Base { void setup(); } interface FeatureX { void x(); } interface FeatureY { void y(); } class Foo: Base, FeatureX { void setup(){}; void x(){}; } D castHelper(D, S)(S s) @trusted if ((is(S == interface) || is(S == class)) && (is(D == interface) || is(D == class))) { import std.traits; D d = cast(D)s; if (d) return d; else assert(0, fullyQualifiedName!S ~ " does not inherit from " ~ fullyQualifiedName!D); } void main() { auto foo = new Foo(); // This would be the result of a factory castHelper!FeatureX(foo).x; }

On Tuesday, 21 May 2019 at 07:04:27 UTC, rumbu wrote: > On Tuesday, 21 May 2019 at 05:51:30 UTC, Jim wrote: > > That's because foo is of type Base, not implementing FeatureX. Right, Base isn't implementing FeatureX, but foo is really a Foo which does: > class Foo: Base, FeatureX > { > void setup(){}; > void x(){}; > } and it works in @system code.

On Tuesday, 21 May 2019 at 05:51:30 UTC, Jim wrote: > Hi, > > consider this: > > interface Base > { > void setup(); > } > > interface FeatureX > { > void x(); > } > > class Foo: Base, FeatureX > { > void setup(){}; > void x(){}; > } > > void main() > { > Base foo = new Foo(); // This would be the result of a factory class > > (cast(FeatureX)foo).x(); // 1 > } > > 1) error: casting to interface FeatureX is not allowed in @safe code. > > Question: How to call foo.x in @safe code ? I got it compiling using `(cast(FeatureX)(cast(Foo)foo)).x();`, but I don't really recommend it. As far as the compiler is concerned, `Base` and `FeatureX` are not related in any way (I'd still expect it to work though). I don't know the circumstances of your problem (so some assumptions here), but usually casting is not the best option. You are basically overriding the type system manually. Some suggestions you can evaluate: - Extend the base interface: interface FeatureX : Base { /+...+/} or interface Combined : FeatureX, Base {} - Change the factory class to return either Foo, FeatureX or a templated type (if it's a more general factory class). This way we can leverage the type system. - You can also make the cast @trusted, but that seems like it kinda defeats the purpose of the function being @safe... --- Returning to the original point (the cast is disallowed in safe code), I don't think it is listed in the spec: https://dlang.org/spec/function.html#safe-functions Unless I am missing some implementation details about interfaces, I would expect it to work just like class casts (i.e. return null on a failed cast, thereby having defined behaviour, thereby being @safe).

On Tuesday, 21 May 2019 at 07:16:49 UTC, Jim wrote: > On Tuesday, 21 May 2019 at 07:04:27 UTC, rumbu wrote: >> On Tuesday, 21 May 2019 at 05:51:30 UTC, Jim wrote: >> >> That's because foo is of type Base, not implementing FeatureX. > > Right, Base isn't implementing FeatureX, but foo is really a Foo That's your knowledge, for the compiler foo is really a Base, as written in your own code. The only way to tell the compiler that you safely assume that foo is really a Foo, is to mark code as @trusted, not @safe. interface Base { void setup(); } interface FeatureX { @safe void x(); } class Foo: Base, FeatureX { void setup(){}; @safe void x(){}; } @trusted FeatureX imsureitsfeaturex(Base b) { return cast(FeatureX)b; } @safe void main() { Base foo = new Foo(); // This would be the result of a factory class imsureitsfeaturex(foo).x(); // 1 }