diff --git a/docs/tree.rst b/docs/tree.rst
index b766853..f841dd1 100644
--- a/docs/tree.rst
+++ b/docs/tree.rst
@@ -202,6 +202,31 @@ Declarations
    A subclass of :py:class:`gcc.Declaration` indicating the declaration of a
    function.   Internally, this wraps a `(struct tree_function_decl *)`
 
+   .. py:attribute:: fullname
+
+      (string) The "full name" of this function.  For C++ this will include the
+      scope, return type and default arguments.
+
+      For example, given this code:
+
+      .. code-block:: c++
+
+         namespace Example {
+             struct Coord {
+                 int x;
+                 int y;
+             };
+
+             class Widget {
+             public:
+                 void set_location(const struct Coord& coord);
+             };
+         };
+
+       set_location's fullname is:
+
+          'void Example::Widget::set_location(const Example::Coord&)'
+
    .. py:attribute:: function
 
       The :py:class:`gcc.Function` for this declaration
@@ -221,6 +246,22 @@ Declarations
       The :py:class:`gcc.CallgraphNode` for this function declaration, or
       `None`
 
+   .. py:attribute:: is_public
+
+      (bool) For C++: is this declaration "public"
+
+   .. py:attribute:: is_private
+
+      (bool) For C++: is this declaration "private"
+
+   .. py:attribute:: is_protected
+
+      (bool) For C++: is this declaration "protected"
+
+   .. py:attribute:: is_static
+
+      (bool) For C++: is this declaration "static"
+
 .. py:class:: gcc.VarDecl
 
    A subclass of :py:class:`gcc.Declaration` indicating the declaration of a
@@ -416,6 +457,18 @@ Additional attributes for various :py:class:`gcc.Type` subclasses:
           * the attribute is present, with a list of 1-based argument indices
             (Note that the result is still 0-based)
 
+.. py:class:: gcc.MethodType
+
+   Subclass of :py:class:`gcc.Type` representing the type of a given method.
+   Similar to :py:class:`gcc.FunctionType`
+
+   The `type` attribute holds the return type.
+
+   .. py:attribute:: argument_types
+
+      A tuple of :py:class:`gcc.Type` instances, representing the function's
+      argument types
+
 Constants
 ---------
 
diff --git a/gcc-python-tree.c b/gcc-python-tree.c
index 625938e..2943b79 100644
--- a/gcc-python-tree.c
+++ b/gcc-python-tree.c
@@ -297,6 +297,11 @@ gcc_FunctionType_get_argument_types(struct PyGccTree * self, void *closure)
     return NULL;
 }
 
+PyObject *
+gcc_MethodType_get_argument_types(struct PyGccTree * self,void *closure)
+{
+    return gcc_FunctionType_get_argument_types(self, closure);
+}
 
 PyObject *
 gcc_Constructor_get_elements(PyObject *self, void *closure)
diff --git a/gcc-python-wrappers.h b/gcc-python-wrappers.h
index fc3bf8e..731d04d 100644
--- a/gcc-python-wrappers.h
+++ b/gcc-python-wrappers.h
@@ -130,6 +130,9 @@ PyObject *
 gcc_IntegerConstant_repr(struct PyGccTree * self);
 
 PyObject *
+gcc_MethodType_get_argument_types(struct PyGccTree * self,void *closure);
+
+PyObject *
 gcc_StringConstant_repr(struct PyGccTree * self);
 
 PyObject *
diff --git a/generate-tree-c.py b/generate-tree-c.py
index 079bb1b..9e6e9e4 100644
--- a/generate-tree-c.py
+++ b/generate-tree-c.py
@@ -28,6 +28,7 @@ cu.add_include('gcc-python.h')
 cu.add_include('gcc-python-wrappers.h')
 cu.add_include('gcc-plugin.h')
 cu.add_include("tree.h")
+cu.add_include("cp/cp-tree.h")
 cu.add_include("function.h")
 cu.add_include("basic-block.h")
 cu.add_include("c-family/c-common.h")
@@ -63,7 +64,10 @@ gcc_Tree_get_addr(struct PyGccTree *self, void *closure)
                                     PyGetSetDef('addr', 'gcc_Tree_get_addr', None,
                                                 'The address of the underlying GCC object in memory'),
                                     PyGetSetDef('str_no_uid', 'gcc_Tree_get_str_no_uid', None,
-                                                'A string representation of this object, like str(), but without including any internal UID')])
+                                                'A string representation of this object, like str(), but without including any internal UID')],
+                                   identifier_prefix='gcc_Tree',
+                                   typename='PyGccTree')
+
     cu.add_defn(getsettable.c_defn())
     
     pytype = PyTypeObject(identifier = 'gcc_TreeType',
@@ -298,7 +302,9 @@ def generate_tree_code_classes():
 
         cc = tree_type.camel_cased_string()
 
-        getsettable =  PyGetSetDefTable('gcc_%s_getset_table' % cc, [])
+        getsettable =  PyGetSetDefTable('gcc_%s_getset_table' % cc, [],
+                                        identifier_prefix='gcc_%s' % cc,
+                                        typename='PyGccTree')
 
         tp_as_number = None
         tp_repr = None
@@ -462,7 +468,23 @@ def generate_tree_code_classes():
                                   None,
                                   "A tuple of gcc.Type instances, representing the argument types of this function type")
 
+        if tree_type.SYM == 'METHOD_TYPE':
+            getsettable.add_gsdef('argument_types',
+                                  'gcc_MethodType_get_argument_types',
+                                  None,
+                                  "A tuple of gcc.Type instances, representing the argument types of this method type")
+
         if tree_type.SYM == 'FUNCTION_DECL':
+            # The TFF_ flags are found in cp/cp-tree.h
+            # Unfortunately, decl_as_string() is only available from C++
+            # frontend (it's defined in gcc/cp/error.c)
+            add_simple_getter('fullname',
+                              ('gcc_python_string_from_string(decl_as_string (self->t,\n'
+                               '   TFF_DECL_SPECIFIERS\n'
+                               '   |TFF_RETURN_TYPE\n'
+                               '   |TFF_FUNCTION_DEFAULT_ARGUMENTS\n'
+                               '   |TFF_EXCEPTION_SPECIFICATION))'),
+                              'The full name of this function declaration')
             add_simple_getter('function',
                               'gcc_python_make_wrapper_function(DECL_STRUCT_FUNCTION(self->t))',
                               'The gcc.Function (or None) for this declaration')
@@ -476,6 +498,12 @@ def generate_tree_code_classes():
                               'gcc_python_make_wrapper_cgraph_node(cgraph_get_node(self->t))',
                               'The gcc.CallgraphNode for this function declaration, or None')
 
+            for attr in ('public', 'private', 'protected', 'static'):
+                getsettable.add_simple_getter(cu,
+                                              'is_%s' % attr,
+                                              'PyBool_FromLong(TREE_%s(self->t))' % attr.upper(),
+                                              None)
+
         if tree_type.SYM == 'SSA_NAME':
             # c.f. "struct GTY(()) tree_ssa_name":
             add_simple_getter('var',
