CPPScope.cxx

Go to the documentation of this file.

// Bindings
#include "cpyrt.h"
 
using namespace cppjit;
#include "CPPDataMember.h"
#include "CPPEnum.h"
#include "CPPFunction.h"
#include "CPPOverload.h"
#include "CPPScope.h"
#include "CustomPyTypes.h"
#include "Dispatcher.h"
#include "ProxyWrappers.h"
#include "PyStrings.h"
#include "TemplateProxy.h"
#include "TypeManip.h"
#include "Utility.h"
#include "cppjit_interop.h"
 
// Standard
#include <algorithm> // for for_each
#include <cctype>
#include <set>
#include <string.h>
#include <string>
#include <vector>
 
namespace cppjit::cpyrt {
 
extern PyTypeObject CPPInstance_Type;
 
//- helpers ------------------------------------------------------------------
static inline PyObject*
add_template(PyObject* pyclass, const std::string& name,
             std::vector<PyCallable*>* overloads = nullptr) {
  // If templated, the user-facing function must be the template proxy, but the
  // specific lookup must be the current overload, if already found.
 
  const std::string& ncl = TypeManip::clean_type(name);
  PyObject* pyncl = PyUnicode_FromString(ncl.c_str());
  TemplateProxy* pytmpl =
      (TemplateProxy*)PyType_Type.tp_getattro(pyclass, pyncl);
  if (!pytmpl) {
    PyErr_Clear();
    pytmpl = TemplateProxy_New(ncl, ncl, pyclass);
    // cache the template on its clean name
    PyType_Type.tp_setattro(pyclass, pyncl, (PyObject*)pytmpl);
    Py_DECREF(pyncl);
  } else if (!TemplateProxy_CheckExact((PyObject*)pytmpl)) {
    Py_DECREF(pytmpl);
    return nullptr;
  }
 
  if (overloads) {
    // adopt the new overloads
    if (ncl != name)
      for (auto clb : *overloads)
        pytmpl->AdoptTemplate(clb);
    else
      for (auto clb : *overloads)
        pytmpl->AdoptMethod(clb);
  }
 
  // the caller expects a method matching the full name, thus is a
  // specialization was requested, do not return the template yet
  if (ncl == name)
    return (PyObject*)pytmpl;
 
  Py_DECREF(pytmpl);
  return nullptr; // so that caller caches the method on full name
}
 
//= cpyrt type proxy construction/destruction =============================
static PyObject* meta_alloc(PyTypeObject* meta, Py_ssize_t nitems) {
  // pure memory allocation; object initialization is in pt_new
  return PyType_Type.tp_alloc(meta, nitems);
}
 
//----------------------------------------------------------------------------
static void meta_dealloc(CPPScope* scope) {
  if (scope->fFlags & CPPScope::kIsNamespace) {
    if (scope->fImp.fUsing) {
      for (auto pyobj : *scope->fImp.fUsing)
        Py_DECREF(pyobj);
      delete scope->fImp.fUsing;
      scope->fImp.fUsing = nullptr;
    }
  } else if (!(scope->fFlags & CPPScope::kIsPython)) {
    delete scope->fImp.fCppObjects;
    scope->fImp.fCppObjects = nullptr;
  }
  delete scope->fOperators;
  free(scope->fModuleName);
  return PyType_Type.tp_dealloc((PyObject*)scope);
}
 
//-----------------------------------------------------------------------------
static PyObject* meta_getcppname(CPPScope* scope, void*) {
  if ((void*)scope == (void*)&CPPInstance_Type)
    return PyUnicode_FromString("CPPInstance_Type");
  return PyUnicode_FromString(
      interop::GetScopedFinalName(scope->fCppType).c_str());
}
 
//-----------------------------------------------------------------------------
static PyObject* meta_getmodule(CPPScope* scope, void*) {
  if ((void*)scope == (void*)&CPPInstance_Type)
    return PyUnicode_FromString("cppjit.gbl");
 
  if (scope->fModuleName)
    return PyUnicode_FromString(scope->fModuleName);
 
  // get C++ representation of outer scope
  interop::TCppScope_t parent_scope = interop::GetParentScope(scope->fCppType);
  if (parent_scope == interop::GetGlobalScope())
    return PyUnicode_FromString(const_cast<char*>("cppjit.gbl"));
 
  // now peel scopes one by one, pulling in the python naming (which will
  // simply recurse if not overridden in python)
  PyObject* pymodule = nullptr;
  PyObject* pyscope = cpyrt::GetScopeProxy(parent_scope);
  if (pyscope) {
    // get the module of our module
    pymodule = PyObject_GetAttr(pyscope, PyStrings::gModule);
    if (pymodule) {
      // append name of our module
      PyObject* pymodname = PyObject_GetAttr(pyscope, PyStrings::gName);
      if (pymodname) {
        PyUnicode_AppendAndDel(&pymodule, PyUnicode_FromString("."));
        PyUnicode_AppendAndDel(&pymodule, pymodname);
      }
    }
    Py_DECREF(pyscope);
  }
 
  if (pymodule)
    return pymodule;
  PyErr_Clear();
 
  // lookup through python failed, so simply cook up a '::' -> '.' replacement
  std::string modname = interop::GetScopedFinalName(parent_scope);
  TypeManip::cppscope_to_pyscope(modname);
  return PyUnicode_FromString(("cppjit.gbl." + modname).c_str());
}
 
//-----------------------------------------------------------------------------
static int meta_setmodule(CPPScope* scope, PyObject* value, void*) {
  if ((void*)scope == (void*)&CPPInstance_Type) {
    PyErr_SetString(PyExc_AttributeError,
                    "attribute \'__module__\' of 'cppjit.CPPScope\' objects is "
                    "not writable");
    return -1;
  }
 
  const char* newname = PyUnicode_AsUTF8(value);
  if (!value)
    return -1;
 
  free(scope->fModuleName);
  Py_ssize_t sz = PyUnicode_GET_LENGTH(value);
  scope->fModuleName = (char*)malloc(sz + 1);
  memcpy(scope->fModuleName, newname, sz + 1);
 
  return 0;
}
 
//----------------------------------------------------------------------------
static PyObject* meta_repr(CPPScope* scope) {
  // Specialized b/c type_repr expects __module__ to live in the dictionary,
  // whereas it is a property (to save memory).
  if ((void*)scope == (void*)&CPPInstance_Type)
    return PyUnicode_FromFormat(
        const_cast<char*>("<class cppjit.CPPInstance at %p>"), scope);
 
  if (scope->fFlags & (CPPScope::kIsMeta | CPPScope::kIsPython)) {
    // either meta type or Python-side derived class: use default type printing
    return PyType_Type.tp_repr((PyObject*)scope);
  }
 
  // skip in case some Python-side derived meta class
  if (!CPPScope_Check(scope) || !scope->fCppType)
    return PyType_Type.tp_repr((PyObject*)scope);
 
  // printing of C++ classes
  PyObject* modname = meta_getmodule(scope, nullptr);
  std::string clName = interop::GetFinalName(scope->fCppType);
  const char* kind =
      (scope->fFlags & CPPScope::kIsNamespace) ? "namespace" : "class";
 
  PyObject* repr =
      PyUnicode_FromFormat("<%s %s.%s at %p>", kind, PyUnicode_AsUTF8(modname),
                           clName.c_str(), scope);
 
  Py_DECREF(modname);
  return repr;
}
 
//= cpyrt type metaclass behavior =========================================
static PyObject* pt_new(PyTypeObject* subtype, PyObject* args, PyObject* kwds) {
  // Called when CPPScope acts as a metaclass; since type_new always resets
  // tp_alloc, and since it does not call tp_init on types, the metaclass is
  // being fixed up here, and the class is initialized here as well.
 
  // fixup of metaclass (left permanent, and in principle only called once b/c
  // cppjit caches python classes)
  subtype->tp_alloc = (allocfunc)meta_alloc;
  subtype->tp_dealloc = (destructor)meta_dealloc;
 
  // creation of the python-side class; extend the size if this is a smart ptr
  //
  // A namespace can never be a smart pointer, so skip the check for namespaces.
  interop::TCppScope_t raw;
  interop::TCppMethod_t deref;
  if (CPPScope_CheckExact(subtype) &&
      !interop::IsNamespace(((CPPScope*)subtype)->fCppType)) {
    if (interop::GetSmartPtrInfo(((CPPScope*)subtype)->fCppType, &raw, &deref))
      subtype->tp_basicsize = sizeof(CPPSmartClass);
  }
 
  CPPScope* result = (CPPScope*)PyType_Type.tp_new(subtype, args, kwds);
  if (!CPPScope_Check(result)) {
    // either failed or custom user-side metaclass that can't be handled here
    return nullptr;
  }
 
  result->fFlags = CPPScope::kNone;
  result->fOperators = nullptr;
  result->fModuleName = nullptr;
 
  if (raw && deref) {
    result->fFlags |= CPPScope::kIsSmart;
    ((CPPSmartClass*)result)->fUnderlyingType = raw;
    ((CPPSmartClass*)result)->fDereferencer = deref;
  }
 
  // initialization of class (based on metatype)
  if (!CPPScope_CheckExact(subtype) ||
      !strstr(subtype->tp_name, "_meta") /* convention */) {
    // there has been a user meta class override in a derived class, so do
    // the consistent thing, thus allowing user control over naming
    result->fCppType =
        interop::GetScope(PyUnicode_AsUTF8(PyTuple_GET_ITEM(args, 0)));
  } else {
    // coming here from cppjit or from sub-classing in python; take the
    // C++ type from the meta class to make sure that the latter category
    // has fCppType properly set (it inherits the meta class, but has an
    // otherwise unknown (or wrong) C++ type)
    result->fCppType = ((CPPScope*)subtype)->fCppType;
 
    // the following is not robust, but by design, C++ classes get their
    // dictionaries filled after creation (chicken & egg problem as they
    // can return themselves in methods), whereas a derived Python class
    // with method overrides will have a non-empty dictionary (even if it
    // has no methods, it will at least have a module name)
    if (3 <= PyTuple_GET_SIZE(args)) {
      PyObject* dct = PyTuple_GET_ITEM(args, 2);
      Py_ssize_t sz = PyDict_Size(dct);
      if (0 < sz && !interop::IsNamespace(result->fCppType)) {
        result->fFlags |= CPPScope::kIsPython;
        if (1 < PyTuple_GET_SIZE(PyTuple_GET_ITEM(args, 1)))
          result->fFlags |= CPPScope::kIsMultiCross;
        std::ostringstream errmsg;
        if (!InsertDispatcher(result, PyTuple_GET_ITEM(args, 1), dct, errmsg)) {
          PyErr_Format(PyExc_TypeError,
                       "no python-side overrides supported (%s)",
                       errmsg.str().c_str());
          return nullptr;
        } else {
          // the direct base can be useful for some templates, such as
          // shared_ptrs, so make it accessible (the __cpp_cross__ data member
          // also signals that this is a cross-inheritance class)
          PyObject* bname = PyUnicode_FromString(
              interop::GetBaseName(result->fCppType, 0).c_str());
          if (!bname)
            PyErr_Clear();
          else {
            if (PyObject_SetAttrString((PyObject*)result, "__cpp_cross__",
                                       bname) == -1)
              PyErr_Clear();
            Py_DECREF(bname);
          }
        }
      } else if (sz == (Py_ssize_t)-1)
        PyErr_Clear();
    }
  }
 
  // if the user messed with the metaclass, then we may not have a C++ type,
  // simply return here before more damage gets done
  if (!result->fCppType)
    return (PyObject*)result;
 
  // maps for using namespaces and tracking objects
  if (!interop::IsNamespace(result->fCppType)) {
    static interop::TCppScope_t exc_type =
        interop::GetScope("exception", interop::GetScope("std"));
    if (interop::IsSubclass(result->fCppType, exc_type))
      result->fFlags |= CPPScope::kIsException;
    if (!(result->fFlags & CPPScope::kIsPython))
      result->fImp.fCppObjects = new CppToPyMap_t;
    else {
      // special case: the C++ objects should be stored with the associated C++,
      // not Python, type
      CPPClass* kls = (CPPClass*)GetScopeProxy(result->fCppType);
      if (kls) {
        result->fImp.fCppObjects = kls->fImp.fCppObjects;
        Py_DECREF(kls);
      } else
        result->fImp.fCppObjects = nullptr;
    }
  } else {
    result->fImp.fUsing = nullptr;
    result->fFlags |= CPPScope::kIsNamespace;
  }
 
  if (PyErr_Occurred()) {
    Py_DECREF((PyObject*)result);
    return nullptr;
  }
 
  return (PyObject*)result;
}
 
//----------------------------------------------------------------------------
static bool IsPlainIdentifier(const std::string& name) {
  if (name.empty() || std::isdigit((unsigned char)name[0]))
    return false;
  for (char c : name) {
    if (!std::isalnum((unsigned char)c) && c != '_')
      return false;
  }
  return true;
}
 
// Returns weak references to the proxies of the namespaces that the namespace
// \c pyclass pulls in with "using namespace", refreshing the list as needed.
static const std::vector<PyObject*>& GetUsingScopes(PyObject* pyclass) {
  CPPScope* klass = (CPPScope*)pyclass;
  const std::vector<interop::TCppScope_t>& uv =
      interop::GetUsingNamespaces(klass->fCppType);
  if (!klass->fImp.fUsing || uv.size() != klass->fImp.fUsing->size()) {
    if (klass->fImp.fUsing) {
      for (auto pyref : *klass->fImp.fUsing)
        Py_DECREF(pyref);
      klass->fImp.fUsing->clear();
    } else
      klass->fImp.fUsing = new std::vector<PyObject*>;
 
    // reload and reset weak refs
    for (auto uid : uv) {
      std::string uname = interop::GetScopedFinalName(uid);
      PyObject* pyuscope = CreateScopeProxy(uname);
      if (pyuscope) {
        klass->fImp.fUsing->push_back(PyWeakref_NewRef(pyuscope, nullptr));
        // the namespace may not otherwise be held, so tie the lifetimes
        PyObject* llname =
            PyUnicode_FromString(("__lifeline_" + uname).c_str());
        PyType_Type.tp_setattro(pyclass, llname, pyuscope);
        Py_DECREF(llname);
        Py_DECREF(pyuscope);
      } else {
        PyErr_Clear();
      }
    }
  }
  return *klass->fImp.fUsing;
}
 
// Checks whether \c pyname is set as a Python attribute on any namespace that
// \c pyclass pulls in with "using namespace", directly or transitively.
static bool HasPythonAttrInUsing(PyObject* pyclass, PyObject* pyname,
                                 std::set<PyObject*>& visited) {
  for (auto pyref : GetUsingScopes(pyclass)) {
    PyObject* pyuscope = cpyrt_GetWeakRef(pyref);
    if (!pyuscope)
      continue;
    bool found = false;
    if (visited.insert(pyuscope).second) {
      found = _PyType_Lookup((PyTypeObject*)pyuscope, pyname) ||
              _PyType_Lookup(Py_TYPE(pyuscope), pyname) ||
              (CPPScope_Check(pyuscope) &&
               (((CPPScope*)pyuscope)->fFlags & CPPScope::kIsNamespace) &&
               HasPythonAttrInUsing(pyuscope, pyname, visited));
    }
    Py_DECREF(pyuscope);
    if (found)
      return true;
  }
  return false;
}
 
//----------------------------------------------------------------------------
static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname) {
  // normal type-based lookup
  PyObject* attr = PyType_Type.tp_getattro(pyclass, pyname);
  if (pyclass == (PyObject*)&CPPInstance_Type)
    return attr;
 
  PyObject* possibly_shadowed = nullptr;
  if (attr) {
    if (CPPScope_Check(attr) && CPPScope_Check(pyclass) &&
        !(((CPPScope*)pyclass)->fFlags & CPPScope::kIsNamespace)) {
      // TODO: the goal here is to prevent typedefs that are shadowed in
      // subclasses to be found as from the base class. The better approach
      // would be to find all typedefs at class creation and insert placeholders
      // to flag here. The current typedef loop in gInterpreter won't do,
      // however.
      PyObject* dct = PyObject_GetAttr(pyclass, PyStrings::gDict);
      if (dct) {
        PyObject* attr_from_dict = PyObject_GetItem(dct, pyname);
        Py_DECREF(dct);
        if (attr_from_dict) {
          Py_DECREF(attr);
          return attr_from_dict;
        }
        possibly_shadowed = attr;
        attr = nullptr;
      }
      PyErr_Clear();
    } else if (CPPScope_Check(attr) && CPPScope_Check(pyclass) &&
               ((CPPScope*)attr)->fFlags & CPPScope::kIsException) {
      return CreateExcScopeProxy(attr, pyname, pyclass);
    } else
      return attr;
  }
 
  if (!PyUnicode_CheckExact(pyname) || !CPPScope_Check(pyclass))
    return possibly_shadowed;
 
  // filter for python specials
  std::string name = PyUnicode_AsUTF8(pyname);
  if (name.size() >= 5 && name.compare(0, 2, "__") == 0 &&
      name.compare(name.size() - 2, name.size(), "__") == 0)
    return possibly_shadowed;
 
  // more elaborate search in case of failure (eg. for inner classes on demand)
  std::vector<Utility::PyError_t> errors;
  Utility::FetchError(errors);
  attr = CreateScopeProxy(name, pyclass);
 
  if (CPPScope_Check(attr) &&
      (((CPPScope*)attr)->fFlags & CPPScope::kIsException)) {
    // Instead of the CPPScope, return a fresh exception class derived from
    // CPPExcInstance.
    return CreateExcScopeProxy(attr, pyname, pyclass);
  }
 
  bool templated_functions_checked = false;
  CPPScope* klass = ((CPPScope*)pyclass);
  if (!attr) {
    Utility::FetchError(errors);
    interop::TCppScope_t scope = klass->fCppType;
 
    // namespaces may have seen updates in their list of global functions, which
    // are available as "methods" even though they're not really that
    if ((klass->fFlags & CPPScope::kIsNamespace) ||
        scope == interop::GetGlobalScope()) {
      // tickle lazy lookup of functions
      const std::vector<interop::TCppMethod_t> methods =
          interop::GetMethodsFromName(scope, name);
      if (!methods.empty()) {
        // function exists, now collect overloads
        std::vector<PyCallable*> overloads;
        for (auto method : methods) {
          overloads.push_back(new CPPFunction(scope, method));
        }
 
        // Note: can't re-use Utility::AddClass here, as there's the risk of
        // a recursive call. Simply add method directly, as we're guaranteed
        // that it doesn't exist yet.
        if (interop::ExistsMethodTemplate(scope, name))
          attr = add_template(pyclass, name, &overloads);
        else
          attr = (PyObject*)CPPOverload_New(name, overloads);
        templated_functions_checked = true;
      }
    }
 
    interop::TCppScope_t lookup_result = nullptr;
    if (!attr) {
      lookup_result = interop::GetNamed(name, scope);
      if (interop::IsVariable(lookup_result) ||
          interop::IsEnumConstant(lookup_result)) {
        attr = (PyObject*)CPPDataMember_New(scope, lookup_result);
      } else if (interop::IsTypedefed(lookup_result)) {
        interop::TCppType_t resolved_type =
            interop::ResolveType(interop::GetTypeFromScope(lookup_result));
        const std::string& cpd =
            TypeManip::compound(interop::GetTypeAsString(resolved_type));
        if (cpd == "*") {
          interop::TCppScope_t tcl =
              interop::GetScopeFromType(interop::ResolveType(resolved_type));
          if (tcl) {
            typedefpointertoclassobject* tpc = PyObject_New(
                typedefpointertoclassobject, &TypedefPointerToClass_Type);
            tpc->fCppType = tcl;
            attr = (PyObject*)tpc;
          }
        }
      }
    }
 
    // function templates that have not been instantiated (namespaces _may_ have
    // already been taken care of, by their general function lookup above)
    if (!attr && !templated_functions_checked) {
      if (interop::ExistsMethodTemplate(scope, name))
        attr = add_template(pyclass, name);
      else {
        // for completeness in error reporting
        PyErr_Format(PyExc_TypeError, "\'%s\' is not a known C++ template",
                     name.c_str());
        Utility::FetchError(errors);
      }
    }
 
    // enums types requested as type (rather than the constants)
    if (!attr) {
      interop::TCppScope_t enumerator =
          interop::GetUnderlyingScope(lookup_result);
      if (interop::IsEnumScope(enumerator)) {
        // enum types (incl. named and class enums)
        attr = (PyObject*)CPPEnum_New(name, enumerator);
      } else {
        // for completeness in error reporting
        PyErr_Format(PyExc_TypeError, "\'%s\' is not a known C++ enum",
                     name.c_str());
        Utility::FetchError(errors);
      }
    }
 
    if (attr) {
      // cache the result
      if (CPPDataMember_Check(attr)) {
        PyType_Type.tp_setattro((PyObject*)Py_TYPE(pyclass), pyname, attr);
 
        Py_DECREF(attr);
        // The call below goes through "dm_get"
        attr = PyType_Type.tp_getattro(pyclass, pyname);
        if (!attr && PyErr_Occurred())
          Utility::FetchError(errors);
      } else
        PyType_Type.tp_setattro(pyclass, pyname, attr);
 
    } else {
      Utility::FetchError(errors);
    }
  }
 
  if (!attr && (klass->fFlags & CPPScope::kIsNamespace)) {
    const std::vector<PyObject*>& using_scopes = GetUsingScopes(pyclass);
 
    // Searching the using namespaces repeats the full attribute lookup in each
    // of them, which is expensive for names that don't exist. Anything C++ it
    // can find is also found by a single unqualified lookup from within this
    // namespace, which follows the using-directives. If that finds nothing,
    // only attributes set on the Python proxies of the using namespaces remain.
    bool search_using = !using_scopes.empty();
    if (search_using && IsPlainIdentifier(name) && !interop::IsBuiltin(name) &&
        !interop::IsVisibleName(name, klass->fCppType)) {
      std::set<PyObject*> visited{pyclass};
      search_using = HasPythonAttrInUsing(pyclass, pyname, visited);
    }
 
    // try all outstanding using namespaces in turn to find the attribute (will
    // cache locally later; TODO: doing so may cause pathological cases)
    for (auto pyref : using_scopes) {
      if (!search_using)
        break;
      PyObject* pyuscope = cpyrt_GetWeakRef(pyref);
      if (pyuscope) {
        attr = PyObject_GetAttr(pyuscope, pyname);
        if (!attr)
          PyErr_Clear();
        Py_DECREF(pyuscope);
      }
      if (attr)
        break;
    }
  }
 
  // if the attribute was not found but could possibly have been shadowed,
  // insert it into the dict now, to short-circuit future lookups (TODO: this is
  // part of the workaround described above of which the true solution is to
  // loop over all typedefs at creation time for the class)
  if (possibly_shadowed) {
    if (attr) {
      Py_DECREF(possibly_shadowed);
    } else {
      attr = possibly_shadowed;
      PyType_Type.tp_setattro(pyclass, pyname, attr);
    }
  }
 
  if (attr) {
    PyErr_Clear();
  } else {
    // not found: prepare a full error report
    PyObject* topmsg = nullptr;
    PyObject *pytype = 0, *pyvalue = 0, *pytrace = 0;
    PyErr_Fetch(&pytype, &pyvalue, &pytrace);
    PyObject* sklass = PyObject_Str(pyclass);
    PyErr_Restore(pytype, pyvalue, pytrace);
    if (sklass) {
      topmsg = PyUnicode_FromFormat(
          "%s has no attribute \'%s\'. Full details:", PyUnicode_AsUTF8(sklass),
          PyUnicode_AsUTF8(pyname));
      Py_DECREF(sklass);
    } else {
      topmsg = PyUnicode_FromFormat("no such attribute \'%s\'. Full details:",
                                    PyUnicode_AsUTF8(pyname));
    }
    SetDetailedException(std::move(errors), topmsg /* steals */,
                         PyExc_AttributeError /* default error */);
  }
 
  return attr;
}
 
//----------------------------------------------------------------------------
static int meta_setattro(PyObject* pyclass, PyObject* pyname, PyObject* pyval) {
  // Global data and static data in namespaces is found lazily, thus if the
  // first use is setting of the global data by the user, it will not be
  // reflected on the C++ side, b/c there is no descriptor yet. This triggers
  // the creation for for such data as necessary. The many checks to narrow down
  // the specific case are needed to prevent unnecessary lookups and recursion.
  // skip if the given pyval is a descriptor already, or an unassignable class
  if (((CPPScope*)pyclass)->fFlags & CPPScope::kIsNamespace &&
      !cpyrt::CPPDataMember_Check(pyval) && !cpyrt::CPPScope_Check(pyval)) {
    std::string name = PyUnicode_AsUTF8(pyname);
    if (interop::GetNamed(name, ((CPPScope*)pyclass)->fCppType)) {
      PyObject* attr = meta_getattro(pyclass, pyname); // triggers creation
      if (!attr)
        PyErr_Clear();
      else
        Py_DECREF(attr);
    }
  }
 
  return PyType_Type.tp_setattro(pyclass, pyname, pyval);
}
 
//----------------------------------------------------------------------------
static PyObject* meta_reflex(CPPScope* klass, PyObject* args) {
  // Provide the requested reflection information.
  interop::Reflex::RequestId_t request = -1;
  interop::Reflex::FormatId_t format = interop::Reflex::OPTIMAL;
  if (!PyArg_ParseTuple(args, const_cast<char*>("i|i:__cpp_reflex__"), &request,
                        &format))
    return nullptr;
 
  switch (request) {
  case interop::Reflex::IS_NAMESPACE:
    if (klass->fFlags & CPPScope::kIsNamespace)
      Py_RETURN_TRUE;
    Py_RETURN_FALSE;
    break;
  case interop::Reflex::IS_AGGREGATE:
    // this is not the strict C++ definition of aggregates, but is closer to
    // what is needed for Numba and C calling conventions (TODO: probably have
    // to check for all public data types, too, and maybe for no padding?)
    if (interop::IsAggregate(klass->fCppType) ||
        !interop::HasVirtualDestructor(klass->fCppType))
      Py_RETURN_TRUE;
    Py_RETURN_FALSE;
    break;
  }
 
  PyErr_Format(PyExc_ValueError, "unsupported reflex request %d or format %d",
               request, format);
  return nullptr;
}
 
//----------------------------------------------------------------------------
// p2.7 does not have a __dir__ in object, and object.__dir__ in p3 does not
// quite what I'd expected of it, so the following pulls in the internal code
#include "PyObjectDir27.inc"
 
static PyObject* meta_dir(CPPScope* klass) {
  // Collect a list of everything (currently) available in the namespace.
  // The backend can filter by returning empty strings. Special care is
  // taken for functions, which need not be unique (overloading).
  using namespace cppjit::interop;
 
  if ((void*)klass == (void*)&CPPInstance_Type)
    return PyList_New(0);
 
  if (!cpyrt::CPPScope_Check((PyObject*)klass)) {
    PyErr_SetString(PyExc_TypeError, "C++ proxy scope expected");
    return nullptr;
  }
 
  PyObject* dirlist = _generic_dir((PyObject*)klass);
  if (!(klass->fFlags & CPPScope::kIsNamespace))
    return dirlist;
 
  std::set<std::string> cppnames;
  interop::GetAllCppNames(klass->fCppType, cppnames);
 
  // cleanup names
  std::set<std::string> dir_cppnames;
  for (const std::string& name : cppnames) {
    if (name.find("__", 0, 2) != std::string::npos ||
        name.find("<") != std::string::npos ||
        name.find("operator", 0, 8) != std::string::npos)
      continue;
    dir_cppnames.insert(name);
  }
 
  // get rid of duplicates
  for (Py_ssize_t i = 0; i < PyList_GET_SIZE(dirlist); ++i)
    dir_cppnames.insert(PyUnicode_AsUTF8(PyList_GET_ITEM(dirlist, i)));
 
  Py_DECREF(dirlist);
  dirlist = PyList_New(dir_cppnames.size());
 
  // copy total onto python list
  Py_ssize_t i = 0;
  for (const auto& name : dir_cppnames) {
    PyList_SET_ITEM(dirlist, i++, PyUnicode_FromString(name.c_str()));
  }
  return dirlist;
}
 
//-----------------------------------------------------------------------------
static PyMethodDef meta_methods[] = {
    {(char*)"__cpp_reflex__", (PyCFunction)meta_reflex, METH_VARARGS,
     (char*)"C++ datamember reflection information"},
    {(char*)"__dir__", (PyCFunction)meta_dir, METH_NOARGS, nullptr},
    {(char*)nullptr, nullptr, 0, nullptr}};
 
//-----------------------------------------------------------------------------
static PyGetSetDef meta_getset[] = {
    {(char*)"__cpp_name__", (getter)meta_getcppname, nullptr, nullptr, nullptr},
    {(char*)"__module__", (getter)meta_getmodule, (setter)meta_setmodule,
     nullptr, nullptr},
    {(char*)nullptr, nullptr, nullptr, nullptr, nullptr}};
 
//= cpyrt object proxy type type ==========================================
PyTypeObject CPPScope_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)(char*) "cppjit.CPPScope", // tp_name
    sizeof(cpyrt::CPPScope),     // tp_basicsize
    0,                           // tp_itemsize
    0,                           // tp_dealloc
    0,                           // tp_vectorcall_offset / tp_print
    0,                           // tp_getattr
    0,                           // tp_setattr
    0,                           // tp_as_async / tp_compare
    (reprfunc)meta_repr,         // tp_repr
    0,                           // tp_as_number
    0,                           // tp_as_sequence
    0,                           // tp_as_mapping
    0,                           // tp_hash
    0,                           // tp_call
    0,                           // tp_str
    (getattrofunc)meta_getattro, // tp_getattro
    (setattrofunc)meta_setattro, // tp_setattro
    0,                           // tp_as_buffer
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
        Py_TPFLAGS_TYPE_SUBCLASS,       // tp_flags
    (char*)"cpyrt metatype (internal)", // tp_doc
    0,                                  // tp_traverse
    0,                                  // tp_clear
    0,                                  // tp_richcompare
    0,                                  // tp_weaklistoffset
    0,                                  // tp_iter
    0,                                  // tp_iternext
    meta_methods,                       // tp_methods
    0,                                  // tp_members
    meta_getset,                        // tp_getset
    &PyType_Type,                       // tp_base
    0,                                  // tp_dict
    0,                                  // tp_descr_get
    0,                                  // tp_descr_set
    0,                                  // tp_dictoffset
    0,                                  // tp_init
    0,                                  // tp_alloc
    (newfunc)pt_new,                    // tp_new
    0,                                  // tp_free
    0,                                  // tp_is_gc
    0,                                  // tp_bases
    0,                                  // tp_mro
    0,                                  // tp_cache
    0,                                  // tp_subclasses
    0,                                  // tp_weaklist
    0,                                  // tp_del
    0,                                  // tp_version_tag
    0,                                  // tp_finalize
    0                                   // tp_vectorcall
    CPYRT_PYTYPE_TAIL};
 
} // namespace cppjit::cpyrt