[python bindings] Expose template argument API for Type

[kjteske]

Summary

Expose the C bindings for clang_Type_getNumTemplateArguments() and clang_Type_getTemplateArgumentAsType() in the python API.

[kjteske]

Thanks for the review @jbcoe , could you commit this for me?

[jbcoe]

I can commit this. Thanks for the great work!

bindings/python/clang/cindex.py

def from_result(res, fn, args):
                 tu = arg.translation_unit
                 break
 
         assert tu is not None
         res._tu = tu
 
         return res
 
+    def get_num_template_arguments(self):
+        return conf.lib.clang_Type_getNumTemplateArguments(self)
+
+    def get_template_argument_type(self, num):
+        return conf.lib.clang_Type_getTemplateArgumentAsType(self, num)
+
     def get_canonical(self):
         """
         Return the canonical type for a Type.
 
         Clang's type system explicitly models typedefs and all the
         ways a specific type can be represented.  The canonical type
         is the underlying type with all the "sugar" removed.  For
         example, if 'T' is a typedef for 'int', the canonical type for
#  CXTUResourceUsage),
    [Type],
    c_longlong),
 
   ("clang_Type_getClassType",
    [Type],
    Type,
    Type.from_result),
 
+  ("clang_Type_getNumTemplateArguments",
+   [Type],
+   c_int),
+
+  ("clang_Type_getTemplateArgumentAsType",
+   [Type, c_uint],
+   Type,
+   Type.from_result),
+
   ("clang_Type_getOffsetOf",
    [Type, c_interop_string],
    c_longlong),
 
   ("clang_Type_getSizeOf",
    [Type],
    c_longlong),
 

bindings/python/tests/cindex/test_type.py

#include <stdarg.h>
     def test_addrspace(self):
         """Ensure the address space can be queried"""
         tu = get_tu('__attribute__((address_space(2))) int testInteger = 3;', 'c')
 
         testInteger = get_cursor(tu, 'testInteger')
 
         self.assertIsNotNone(testInteger, "Could not find testInteger.")
         self.assertEqual(testInteger.type.get_address_space(), 2)
+
+    def test_template_arguments(self):
+        source = """
+        class Foo {
+        };
+        template <typename T>
+        class Template {
+        };
+        Template<Foo> instance;
+        int bar;
+        """
+        tu = get_tu(source, lang='cpp')
+
+        # Varible with a template argument.
+        cursor = get_cursor(tu, 'instance')
+        cursor_type = cursor.type
+        self.assertEqual(cursor.kind, CursorKind.VAR_DECL)
+        self.assertEqual(cursor_type.spelling, 'Template<Foo>')
+        self.assertEqual(cursor_type.get_num_template_arguments(), 1)
+        template_type = cursor_type.get_template_argument_type(0)
+        self.assertEqual(template_type.spelling, 'Foo')
+
+        # Variable without a template argument.
+        cursor = get_cursor(tu, 'bar')
+        self.assertEqual(cursor.get_num_template_arguments(), -1)