a C++ derived class that defines an operator hides automatic base class conversion

[timotheecour]

@Syniurge : a C++ derived class that defines an operator hides automatic base class conversion

test.h:

struct A{ int x;};

struct B : public A{
  // comment to remove error
  operator float() const;
};

main.d:

modmap (C++) "test.h";
import (C++) A;
import (C++) B;

void main(){
  B b;
  int bx=b.x;
}

compiling produces this error:
Error: template instance opCast!(A) does not match template declaration opCast(type : float)

The error goes away if we remove operator float() const;

It works if we add operator A*() {return this;} in B and change the D code to:
int bx=(cast(A*)b).x; but this is obviously not practical.

[timotheecour]

workaround: skip generating opCast!T from C++ operator T()
obviously this is not a good workaround since it'll skip generating some C++ functions

Calypso/ddmd/cpp/calypso.cpp:

Identifier *getIdentifierOrNull(const clang::NamedDecl *D, SpecValue *spec, bool useCanonicalType)

    else if (auto Conv = dyn_cast<clang::CXXConversionDecl>(D))
    {
       // return immediately here, which skips generating opCast!T from C++ `operator T()`
        return nullptr;
       // ...
}

NOTE: I had intially tried in Calypso/ddmd/expression.d CastExp:semantic(Scope* sc) commenting out the block if (Expression e = op_overload(sc)){ but it had worse side effects as it'll just skip existing opCast templates

A better workaround would be to generate opCast(BaseClass*) if at least one clang::CXXConversionDecl is encountered (and generated) but I don't know how this could be done simply in current design. Any help appreciated.

[timotheecour]

still a better workaround (requiring no change in Calypso/ddmd/cpp/calypso.cpp, hence not suppressing generation of opCast's):

Calypso/ddmd/expression.d in class CastExp:

if (!to.equals(e1.type) && mod == cast(ubyte)~0)
        {
            uint errors = global.startGagging();
            Expression e = op_overload(sc);
            if(global.endGagging(errors))
                e=null;
            if(e)
              return e.implicitCastTo(sc, to);
        }

• what could be downsides?
• how could we require this change to only apply for C++ classes?

[timotheecour]

improved version that only gags when both e1.type and to are C++ classes from langPlugin:

                    bool is_cpp_class(Type t){
                        // NOTE: this doesn't work:
                        // if(auto cd = t.isClassHandle()) return cd.isCPPclass();

                        Type tv = t.baseElemOf();
                        if (!tv.isAggregateValue()) return false;
                        if(!tv.getAggregateSym().langPlugin()) return false;
                        return true;
                    }
                    if(!is_cpp_class(e1.type)) goto Handle_default;
                    if(!is_cpp_class(to)) goto Handle_default;

                    uint errors = global.startGagging();
                    Expression e = op_overload(sc);
                    if(global.endGagging(errors)){
                        e=null;
                    }
                    if(e){
                        return e.implicitCastTo(sc, to);
                    }
                    goto Handle_other; // TODO: needed?
                }

                Handle_default:
                    if (Expression e = op_overload(sc)){
                        return e.implicitCastTo(sc, to);
                    }
                Handle_other:

[Syniurge]

Fixed by c3573b9.