Conflicting tests

[Vipul-Cariappa]

Hi @wlav, I am trying to understand the following 2 tests: test16_opaque_handle and test02_missing_classes.

In the case of test16_opaque_handle, we assert on the existence of OpaqueType, which is a class without a definition (test line, declaration).
But in test02_missing_classes, we expect that accessing no_such_class raises AttributeError, no_such_class is a class without definition (test line, declaration).

Why is it the case that in one instance we expect it to work, but not in the other? Or am I missing something else?

ping @aaronj0 @vgvassilev

[wlav]

This is exploiting subtleties of the dictionary mechanism as a heuristic to decide whether a class is missing by mistake or intentionally not defined. There's nothing at all in the dictionary about no_such_class, so the assumption is that it was accidentally pulled in from some header somewhere, whereas for OpaqueType, the dictionary has added explicit methods:

  <function name="create_handle" />
  <function name="destroy_handle" />

that use that type, so it not being defined, was most likely intentional.

Opaque handles are common on Windows.

[Vipul-Cariappa]

Thanks for the clarification.

[vgvassilev]

Is that the equivalent of incomplete class?

[wlav]

Don't think so. Here's the code:

bool Cppyy::IsComplete(const std::string& type_name)
{
// verify whether the dictionary of this class is fully available
    bool b = false;

    int oldEIL = gErrorIgnoreLevel;
    gErrorIgnoreLevel = 3000;
    TClass* klass = TClass::GetClass(type_name.c_str());
    if (klass && klass->GetClassInfo())     // works for normal case w/ dict
        b = gInterpreter->ClassInfo_IsLoaded(klass->GetClassInfo());
    else {    // special case for forward declared classes
        ClassInfo_t* ci = gInterpreter->ClassInfo_Factory(type_name.c_str());
        if (ci) {
            b = gInterpreter->ClassInfo_IsLoaded(ci);
            gInterpreter->ClassInfo_Delete(ci);  // we own the fresh class info
        }    
    }
    gErrorIgnoreLevel = oldEIL;
    return b;
}

So 2 pieces to it. 1) Cling's class info is checked for having a definition; it does not check whether said definition is complete. This is the bit that basically says "was the class recorded in some dictionary somewhere." And 2) if it's not, a forward declaration is checked the hard way.

For subsequent calls into meta, there are various actual checks for isCompleteDefinition() which turns operations into no-ops if false.