A Python code model for C++ used to drive code generators

[jbcoe]

Summary

I have written a very simple code model for C++ code to allow template-based code generators to consume information from a clang AST.

It is used in an (early stage) open source project: https://github.com/jbcoe/C_API_generation

While the code generator is perhaps a bit use-specific I think that the c++ code model would allow many more people to make easy use of information from libclang through Python.

There are no changes to existing code in this diff, just new code and tests.

[jbcoe]

I was wondering if anyone had looked at this yet?

[jbcoe]

I have updates to this patch if the broad-brush approach is of interest.

[jbcoe]

I've added more python classes to handle types and free functions.

[jbcoe]

Add missing test for types - apologies for noise.

[jbcoe]

Has anyone had a chance to look over this?

[jbcoe]

I'm abandoning this revision for lack of interest.

bindings/python/clang/cppmodel.py

+import os
+import sys
+import clang.cindex
+from clang.cindex import AccessSpecifier, CursorKind, TypeKind
+
+def _get_annotations(node):
+    return [c.displayname for c in node.get_children()
+            if c.kind == CursorKind.ANNOTATE_ATTR]
+
+class Type:
+    def __init__(self, cindex_type):
+        self.kind = cindex_type.kind
+        self.name = cindex_type.spelling
+        self.is_pointer = self.kind == TypeKind.POINTER
+        self.is_reference = self.kind == TypeKind.LVALUEREFERENCE
+        self.is_const = cindex_type.is_const_qualified()
+        if self.is_pointer or self.is_reference:
+            self.pointee = Type(cindex_type.get_pointee())
+        else: self.pointee = None
+
+    def __repr__(self):
+        return self.name
+
+
+class FunctionArgument:
+    def __repr__(self):
+        return str(self.type)+":\""+str(self.name)+"\""
+
+    def __init__(self, type, name):
+        self.type = type
+        self.name = name
+
+
+class _Function(object):
+    def __repr__(self):
+        return str(self.name)
+
+    def __init__(self, cursor):
+        self.name = cursor.spelling
+        arguments = [x.spelling for x in cursor.get_arguments()]
+        argument_types = [Type(x) for x in cursor.type.argument_types()]
+
+        self.return_type = Type(cursor.type.get_result())
+        self.arguments = []
+        self.annotations = _get_annotations(cursor)
+
+        for t,n in zip(argument_types,arguments):
+            self.arguments.append(FunctionArgument(t,n))
+
+
+class Function(_Function):
+
+    def __init__(self, cursor, namespaces=[]):
+        _Function.__init__(self, cursor)
+        self.namespace = '::'.join(namespaces)
+
+
+class Method(Function):
+
+    def __init__(self, cursor):
+        _Function.__init__(self, cursor)
+        self.is_const = cursor.is_const_method()
+        self.is_virtual = cursor.is_virtual_method()
+        self.is_pure_virtual = cursor.is_pure_virtual_method()
+        self.is_public = (cursor.access_specifier == AccessSpecifier.PUBLIC)
+
+
+class Class(object):
+    def __repr__(self):
+        return "Class:%s"%str(self.name)
+
+    def __init__(self, cursor, namespaces):
+        self.name = cursor.spelling
+        self.namespace = '::'.join(namespaces)
+        self.constructors = []
+        self.methods = []
+        self.fields = []
+        self.annotations = _get_annotations(cursor)
+        self.base_classes = []
+
+        for c in cursor.get_children():
+            if (c.kind == CursorKind.CXX_METHOD):
+                f = Method(c)
+                self.methods.append(f)
+            elif (c.kind == CursorKind.CONSTRUCTOR):
+                f = Method(c)
+                self.constructors.append(f)
+            elif (c.kind == CursorKind.CXX_BASE_SPECIFIER):
+                self.base_classes.append(c.type.spelling)
+
+class Model(object):
+    def __repr__(self):
+        return "Classes:[{}]".format(",".join(self.classes))
+
+    def __init__(self, translation_unit):
+       self.functions = []
+       self.classes = []
+       self.add_child_nodes(translation_unit.cursor, [])
+
+    def add_child_nodes(self, cursor, namespaces=[]):
+        for c in cursor.get_children():
+            if c.kind == CursorKind.CLASS_DECL or c.kind == CursorKind.STRUCT_DECL:
+                self.classes.append(Class(c,namespaces))
+            if c.kind == CursorKind.FUNCTION_DECL:
+                self.functions.append(Function(c,namespaces))
+            elif c.kind == CursorKind.NAMESPACE:
+                child_namespaces = list(namespaces)
+                child_namespaces.append(c.spelling)
+                self.add_child_nodes(c, child_namespaces)
+

bindings/python/tests/cppmodel/test_classes.py

+from ..cindex.util import get_tu
+from clang import cppmodel
+from clang.cindex import TypeKind
+
+def test_class_name():
+    source = 'class A{};'
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    classes = model.classes
+
+    assert len(classes)==1
+    assert classes[0].name == 'A'
+
+def test_class_methods():
+    source = """
+    class A{};
+    class B{
+        void foo();
+        int bar();
+    };"""
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    classes = model.classes
+
+    assert len(classes[0].methods) == 0
+    assert len(classes[1].methods) == 2
+
+def test_class_method_return_types():
+    source = """
+    class B{
+        void foo();
+        int bar();
+    };"""
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    classes = model.classes
+
+    assert classes[0].methods[0].return_type.kind == TypeKind.VOID
+    assert classes[0].methods[1].return_type.kind == TypeKind.INT
+
+def test_class_method_argument_types():
+    source = """
+    class A {
+        int foo(int i, const char* p);
+    };"""
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    classes = model.classes
+    args = classes[0].methods[0].arguments
+
+    assert args[0].type.kind == TypeKind.INT
+    assert args[0].name == "i"
+    assert args[1].type.kind == TypeKind.POINTER
+    assert args[1].name == "p"
+
+def test_class_method_const_qualifiers():
+    source = """
+    class A {
+        int foo() const;
+        int bar();
+    };"""
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    classes = model.classes
+    methods = classes[0].methods
+
+    assert methods[0].is_const
+    assert not methods[1].is_const
+
+def test_class_methods_are_virtual():
+    source = """
+    class A {
+        virtual int foo();
+        int bar();
+        virtual int foobar() = 0;
+    };"""
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    classes = model.classes
+    methods = classes[0].methods
+
+    assert methods[0].is_virtual
+    assert not methods[0].is_pure_virtual
+    assert not methods[1].is_virtual
+    assert methods[2].is_pure_virtual
+
+def test_namespaces():
+    source = """
+    class A{};
+    namespace outer {
+        class B{};
+        namespace inner {
+            class C{};
+        } // end inner
+        class D{};
+    } // end outer
+    class E{};"""
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    classes = model.classes
+
+    assert classes[0].namespace == ""
+    assert classes[1].namespace == "outer"
+    assert classes[2].namespace == "outer::inner"
+    assert classes[3].namespace == "outer"
+    assert classes[4].namespace == ""
+
+def test_access_specifiers():
+    source = """
+    class A { int foo(); };
+    struct B { int foo(); };
+    class C { public: int foo(); };
+    """
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    classes = model.classes
+
+    assert not classes[0].methods[0].is_public
+    assert classes[1].methods[0].is_public
+    assert classes[2].methods[0].is_public
+

bindings/python/tests/cppmodel/test_free_functions.py

+from ..cindex.util import get_tu
+from clang import cppmodel
+from clang.cindex import TypeKind
+
+def test_function_name():
+    source = """
+    void foo();
+    void bar();
+    """
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    functions = model.functions
+
+    assert len(functions) == 2
+    assert functions[0].name == 'foo'
+    assert functions[1].name == 'bar'
+
+
+def test_function_return_type():
+    source = """
+    int foo();
+    double* bar();
+    """
+
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    functions = model.functions
+
+    assert functions[0].return_type.kind == TypeKind.INT
+    assert functions[1].return_type.kind == TypeKind.POINTER
+    assert functions[1].return_type.is_pointer
+    assert functions[1].return_type.pointee.kind == TypeKind.DOUBLE
+    assert not functions[1].return_type.pointee.is_const
+
+
+def test_function_arguments():
+    source = """
+    int foo();
+    double bar(int x, char y);
+    """
+
+    tu = get_tu(source, 'cpp')
+
+    model = cppmodel.Model(tu)
+    functions = model.functions
+
+    assert len(functions[0].arguments) == 0
+    assert len(functions[1].arguments) == 2
+    assert functions[1].arguments[0].type.kind == TypeKind.INT
+    assert functions[1].arguments[0].name == 'x'
+    assert functions[1].arguments[1].type.kind == TypeKind.CHAR_S
+    assert functions[1].arguments[1].name == 'y'
+

bindings/python/tests/cppmodel/test_types.py

+from ..cindex.util import get_tu
+from clang import cppmodel
+from clang.cindex import TypeKind
+
+def test_pointer_type():
+    source = "double* pd();"
+
+    tu = get_tu(source, 'cpp')
+    model = cppmodel.Model(tu)
+    f = model.functions[0]
+
+    assert f.return_type.kind == TypeKind.POINTER
+    assert not f.return_type.is_const
+    assert f.return_type.pointee.kind == TypeKind.DOUBLE
+    assert not f.return_type.pointee.is_const
+
+
+def test_const_pointer_to_double_type():
+    source = "double* const cpd();"
+
+    tu = get_tu(source, 'cpp')
+    model = cppmodel.Model(tu)
+    f = model.functions[0]
+
+    assert f.return_type.kind == TypeKind.POINTER
+    assert f.return_type.is_const
+    assert f.return_type.pointee.kind == TypeKind.DOUBLE
+    assert not f.return_type.pointee.is_const
+
+
+def test_const_pointer_to_const_double_type():
+    source = "const double* const cpcd();"
+
+    tu = get_tu(source, 'cpp')
+    model = cppmodel.Model(tu)
+    functions = model.functions
+    f = model.functions[0]
+
+    assert f.return_type.kind == TypeKind.POINTER
+    assert f.return_type.is_const
+    assert f.return_type.pointee.kind == TypeKind.DOUBLE
+    assert f.return_type.pointee.is_const
+
+
+def test_pointer_to_pointer_type():
+    source = "double** ppd();"
+
+    tu = get_tu(source, 'cpp')
+    model = cppmodel.Model(tu)
+    f = model.functions[0]
+
+    assert f.return_type.kind == TypeKind.POINTER
+    assert f.return_type.is_pointer
+    assert f.return_type.pointee.kind == TypeKind.POINTER
+    assert f.return_type.pointee.is_pointer
+    assert f.return_type.pointee.pointee.kind == TypeKind.DOUBLE
+
+
+def test_pointer_to_record_type():
+    source = "class A{}; A* pA();"
+
+    tu = get_tu(source, 'cpp')
+    model = cppmodel.Model(tu)
+    f = model.functions[0]
+
+    assert f.return_type.kind == TypeKind.POINTER
+    assert f.return_type.is_pointer
+    assert f.return_type.pointee.kind == TypeKind.RECORD
+
+def test_reference_to_record_type():
+    source = "class A{}; A& pA();"
+
+    tu = get_tu(source, 'cpp')
+    model = cppmodel.Model(tu)
+    f = model.functions[0]
+
+    assert f.return_type.kind == TypeKind.LVALUEREFERENCE
+    assert not f.return_type.is_pointer
+    assert f.return_type.is_reference
+    assert f.return_type.pointee.kind == TypeKind.RECORD
+