Extended the parser and AST to handle template template parameters.

For more details see the Clang documentation ( http://clang.llvm.org/doxygen/classclang_1_1TemplateTemplateParmDecl.html ).

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/AST/ASTVisitor.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace CppSharp.AST
 {
@@ -453,7 +454,18 @@ namespace CppSharp.AST
             return true;
         }
 
-        public virtual bool VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        public bool VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter)
+        {
+            if (!VisitDeclaration(templateTemplateParameter))
+                return false;
+
+            foreach (var templateParameter in templateTemplateParameter.Parameters)
+                templateParameter.Visit(this);
+
+            return true;
+        }
+
+        public virtual bool VisitTemplateParameterDecl(TypeTemplateParameter templateParameter)
         {
             if (!VisitDeclaration(templateParameter))
                 return false;
@@ -461,7 +473,7 @@ namespace CppSharp.AST
             return true;
         }
 
-        public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        public bool VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter)
         {
             if (!VisitDeclaration(nonTypeTemplateParameter))
                 return false;

src/AST/Declaration.cs

@@ -386,7 +386,8 @@ namespace CppSharp.AST
         T VisitEvent(Event @event);
         T VisitProperty(Property @property);
         T VisitFriend(Friend friend);
-        T VisitTemplateParameter(TypeTemplateParameter templateParameter);
+        T VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter);
-        T VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter);
+        T VisitTemplateParameterDecl(TypeTemplateParameter templateParameter);
+        T VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter);
     }
 }

src/AST/Template.cs

@@ -1,9 +1,43 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace CppSharp.AST
 {
-    public abstract class TemplateParameter : Declaration
+    public class TemplateTemplateParameter : Template
+    {
+        /// <summary>
+        /// Whether this template template parameter is a template parameter pack.
+        /// <para>template&lt;template&lt;class T&gt; ...MetaFunctions&gt; struct Apply;</para>
+        /// </summary>
+        public bool IsParameterPack { get; set; }
+
+        /// <summary>
+        /// Whether this parameter pack is a pack expansion.
+        /// <para>A template template parameter pack is a pack expansion if its template parameter list contains an unexpanded parameter pack.</para>
+        /// </summary>
+        public bool IsPackExpansion { get; set; }
+
+        /// <summary>
+        /// Whether this parameter is a template template parameter pack that has a known list of different template parameter lists at different positions.
+        /// A parameter pack is an expanded parameter pack when the original parameter pack's template parameter list was itself a pack expansion, and that expansion has already been expanded. For exampe, given:
+        /// <para>
+        /// template&lt;typename...Types&gt; struct Outer { template&lt;template&lt;Types&gt; class...Templates> struct Inner; };
+        /// </para>
+        /// The parameter pack Templates is a pack expansion, which expands the pack Types.When Types is supplied with template arguments by instantiating Outer, the instantiation of Templates is an expanded parameter pack.
+        /// </summary>
+        public bool IsExpandedParameterPack { get; set; }
+
+        public override T Visit<T>(IDeclVisitor<T> visitor)
+        {
+            return visitor.VisitTemplateTemplateParameterDecl(this);
+        }
+    }
+
+    /// <summary>
+    /// Represents a template parameter
+    /// </summary>
+    public class TypeTemplateParameter : Declaration
     {
         /// <summary>
         /// Get the nesting depth of the template parameter.
@@ -23,13 +57,7 @@ namespace CppSharp.AST
         /// </para>
         /// </summary>
         public bool IsParameterPack { get; set; }
-    }
 
-    /// <summary>
-    /// Represents a template parameter
-    /// </summary>
-    public class TypeTemplateParameter : TemplateParameter
-    {
         // Generic type constraint
         public string Constraint;
 
@@ -37,15 +65,34 @@ namespace CppSharp.AST
 
         public override T Visit<T>(IDeclVisitor<T> visitor)
         {
-            return visitor.VisitTemplateParameter(this);
+            return visitor.VisitTemplateParameterDecl(this);
         }
     }
 
     /// <summary>
     /// Represents a hard-coded template parameter
     /// </summary>
-    public class NonTypeTemplateParameter : TemplateParameter
+    public class NonTypeTemplateParameter : Declaration
     {
+        /// <summary>
+        /// Get the nesting depth of the template parameter.
+        /// </summary>
+        public uint Depth { get; set; }
+
+        /// <summary>
+        /// Get the index of the template parameter within its parameter list.
+        /// </summary>
+        public uint Index { get; set; }
+
+        /// <summary>
+        /// Whether this parameter is a non-type template parameter pack.
+        /// <para>
+        /// If the parameter is a parameter pack, the type may be a PackExpansionType.In the following example, the Dims parameter is a parameter pack (whose type is 'unsigned').
+        /// <para>template&lt;typename T, unsigned...Dims&gt; struct multi_array;</para>
+        /// </para>
+        /// </summary>
+        public bool IsParameterPack { get; set; }
+
         public Expression DefaultArgument { get; set; }
 
         /// <summary>
@@ -79,7 +126,7 @@ namespace CppSharp.AST
 
         public override T Visit<T>(IDeclVisitor<T> visitor)
         {
-            return visitor.VisitNonTypeTemplateParameter(this);
+            return visitor.VisitNonTypeTemplateParameterDecl(this);
         }
     }
 
@@ -108,18 +155,18 @@ namespace CppSharp.AST
 
         protected Template()
         {
-            Parameters = new List<TemplateParameter>();
+            Parameters = new List<Declaration>();
         }
 
         protected Template(Declaration decl)
         {
             TemplatedDecl = decl;
-            Parameters = new List<TemplateParameter>();
+            Parameters = new List<Declaration>();
         }
 
         public Declaration TemplatedDecl;
 
-        public List<TemplateParameter> Parameters;
+        public List<Declaration> Parameters;
 
         public override string ToString()
         {

src/Core/Parser/ASTConverter.cs

@@ -139,7 +139,8 @@ namespace CppSharp
         public abstract TRet VisitClassTemplatePartialSpecialization(
             ClassTemplatePartialSpecialization decl);
         public abstract TRet VisitFunctionTemplate(FunctionTemplate decl);
-        public abstract TRet VisitTemplateParameter(TypeTemplateParameter decl);
+        public abstract TRet VisitTemplateTemplateParameter(TemplateTemplateParameter decl);
+        public abstract TRet VisitTypeTemplateParameter(TypeTemplateParameter decl);
         public abstract TRet VisitNonTypeTemplateParameter(NonTypeTemplateParameter decl);
 
         public virtual TRet Visit(Parser.AST.Declaration decl)
@@ -231,10 +232,15 @@ namespace CppSharp
                         var _decl = FunctionTemplate.__CreateInstance(decl.__Instance);
                         return VisitFunctionTemplate(_decl);
                     }
+                case DeclarationKind.TemplateTemplateParm:
+                    {
+                        var _decl = TemplateTemplateParameter.__CreateInstance(decl.__Instance);
+                        return VisitTemplateTemplateParameter(_decl);
+                    }
                 case DeclarationKind.TemplateTypeParm:
                     {
                         var _decl = TypeTemplateParameter.__CreateInstance(decl.__Instance);
-                        return VisitTemplateParameter(_decl);
+                        return VisitTypeTemplateParameter(_decl);
                     }
                 case DeclarationKind.NonTypeTemplateParm:
                     {
@@ -1439,7 +1445,7 @@ namespace CppSharp
             for (uint i = 0; i < template.ParametersCount; ++i)
             {
                 var param = template.getParameters(i);
-                var _param = (AST.TemplateParameter) Visit(param);
+                var _param = Visit(param);
                 _template.Parameters.Add(_param);
             }
         }
@@ -1641,7 +1647,7 @@ namespace CppSharp
             return _macro;
         }
 
-        public override AST.Declaration VisitTemplateParameter(TypeTemplateParameter decl)
+        public override AST.Declaration VisitTypeTemplateParameter(TypeTemplateParameter decl)
         {
             var templateParameter = new AST.TypeTemplateParameter();
             VisitDeclaration(decl, templateParameter);
@@ -1665,6 +1671,16 @@ namespace CppSharp
             nonTypeTemplateParameter.IsExpandedParameterPack = decl.IsExpandedParameterPack;
             return nonTypeTemplateParameter;
         }
+
+        public override AST.Declaration VisitTemplateTemplateParameter(TemplateTemplateParameter decl)
+        {
+            var templateTemplateParameter = new AST.TemplateTemplateParameter();
+            VisitTemplate(decl, templateTemplateParameter);
+            templateTemplateParameter.IsParameterPack = decl.IsParameterPack;
+            templateTemplateParameter.IsPackExpansion = decl.IsPackExpansion;
+            templateTemplateParameter.IsExpandedParameterPack = decl.IsExpandedParameterPack;
+            return templateTemplateParameter;
+        }
     }
 
     public unsafe class CommentConverter : CommentsVisitor<AST.Comment>

src/CppParser/AST.cpp

@@ -98,6 +98,18 @@ TemplateParameter::~TemplateParameter()
 {
 }
 
+TemplateTemplateParameter::TemplateTemplateParameter()
+    : Template(DeclarationKind::TemplateTemplateParm)
+    , IsParameterPack(false)
+    , IsPackExpansion(false)
+    , IsExpandedParameterPack(false)
+{
+}
+
+TemplateTemplateParameter::~TemplateTemplateParameter()
+{
+}
+
 // TemplateParameter
 TypeTemplateParameter::TypeTemplateParameter()
     : TemplateParameter(DeclarationKind::TemplateTypeParm)

src/CppParser/AST.h

@@ -356,6 +356,7 @@ enum class DeclarationKind
     MacroExpansion,
     TranslationUnit,
     Friend,
+    TemplateTemplateParm,
     TemplateTypeParm,
     NonTypeTemplateParm
 };
@@ -761,6 +762,17 @@ public:
     bool IsParameterPack;
 };
 
+class CS_API TemplateTemplateParameter : public Template
+{
+public:
+    TemplateTemplateParameter();
+    ~TemplateTemplateParameter();
+
+    bool IsParameterPack;
+    bool IsPackExpansion;
+    bool IsExpandedParameterPack;
+};
+
 class CS_API TypeTemplateParameter : public TemplateParameter
 {
 public:

src/CppParser/Bindings/CLI/AST.cpp

@@ -3531,6 +3531,73 @@ void CppSharp::Parser::AST::TemplateParameter::IsParameterPack::set(bool value)
     ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->IsParameterPack = value;
 }
 
+CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter(::CppSharp::CppParser::AST::TemplateTemplateParameter* native)
+    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
+{
+}
+
+CppSharp::Parser::AST::TemplateTemplateParameter^ CppSharp::Parser::AST::TemplateTemplateParameter::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::AST::TemplateTemplateParameter((::CppSharp::CppParser::AST::TemplateTemplateParameter*) native.ToPointer());
+}
+
+CppSharp::Parser::AST::TemplateTemplateParameter::~TemplateTemplateParameter()
+{
+    if (NativePtr)
+    {
+        auto __nativePtr = NativePtr;
+        NativePtr = 0;
+        delete (::CppSharp::CppParser::AST::TemplateTemplateParameter*) __nativePtr;
+    }
+}
+
+CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter()
+    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
+{
+    __ownsNativeInstance = true;
+    NativePtr = new ::CppSharp::CppParser::AST::TemplateTemplateParameter();
+}
+
+CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter(CppSharp::Parser::AST::TemplateTemplateParameter^ _0)
+    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
+{
+    __ownsNativeInstance = true;
+    if (ReferenceEquals(_0, nullptr))
+        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
+    auto &arg0 = *(::CppSharp::CppParser::AST::TemplateTemplateParameter*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::TemplateTemplateParameter(arg0);
+}
+
+bool CppSharp::Parser::AST::TemplateTemplateParameter::IsParameterPack::get()
+{
+    return ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsParameterPack;
+}
+
+void CppSharp::Parser::AST::TemplateTemplateParameter::IsParameterPack::set(bool value)
+{
+    ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsParameterPack = value;
+}
+
+bool CppSharp::Parser::AST::TemplateTemplateParameter::IsPackExpansion::get()
+{
+    return ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsPackExpansion;
+}
+
+void CppSharp::Parser::AST::TemplateTemplateParameter::IsPackExpansion::set(bool value)
+{
+    ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsPackExpansion = value;
+}
+
+bool CppSharp::Parser::AST::TemplateTemplateParameter::IsExpandedParameterPack::get()
+{
+    return ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsExpandedParameterPack;
+}
+
+void CppSharp::Parser::AST::TemplateTemplateParameter::IsExpandedParameterPack::set(bool value)
+{
+    ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsExpandedParameterPack = value;
+}
+
 CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter(::CppSharp::CppParser::AST::TypeTemplateParameter* native)
     : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)native)
 {

src/CppParser/Bindings/CLI/AST.h

@@ -85,6 +85,7 @@ namespace CppSharp
             ref class TemplateParameterSubstitutionType;
             ref class TemplateParameterType;
             ref class TemplateSpecializationType;
+            ref class TemplateTemplateParameter;
             ref class TextComment;
             ref class TranslationUnit;
             ref class Type;
@@ -152,8 +153,9 @@ namespace CppSharp
                 MacroExpansion = 19,
                 TranslationUnit = 20,
                 Friend = 21,
-                TemplateTypeParm = 22,
+                TemplateTemplateParm = 22,
-                NonTypeTemplateParm = 23
+                TemplateTypeParm = 23,
+                NonTypeTemplateParm = 24
             };
 
             public enum struct AccessSpecifier
@@ -2099,6 +2101,37 @@ namespace CppSharp
                 }
             };
 
+            public ref class TemplateTemplateParameter : CppSharp::Parser::AST::Template
+            {
+            public:
+
+                TemplateTemplateParameter(::CppSharp::CppParser::AST::TemplateTemplateParameter* native);
+                static TemplateTemplateParameter^ __CreateInstance(::System::IntPtr native);
+                TemplateTemplateParameter();
+
+                TemplateTemplateParameter(CppSharp::Parser::AST::TemplateTemplateParameter^ _0);
+
+                ~TemplateTemplateParameter();
+
+                property bool IsParameterPack
+                {
+                    bool get();
+                    void set(bool);
+                }
+
+                property bool IsPackExpansion
+                {
+                    bool get();
+                    void set(bool);
+                }
+
+                property bool IsExpandedParameterPack
+                {
+                    bool get();
+                    void set(bool);
+                }
+            };
+
             public ref class TypeTemplateParameter : CppSharp::Parser::AST::TemplateParameter
             {
             public:

src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/AST.cs

@@ -57,8 +57,9 @@ namespace CppSharp
                 MacroExpansion = 19,
                 TranslationUnit = 20,
                 Friend = 21,
-                TemplateTypeParm = 22,
+                TemplateTemplateParm = 22,
-                NonTypeTemplateParm = 23
+                TemplateTypeParm = 23,
+                NonTypeTemplateParm = 24
             }
 
             public enum AccessSpecifier
@@ -8060,6 +8061,181 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 112)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(12)]
+                    public CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(16)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(20)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(60)]
+                    public byte IsIncomplete;
+
+                    [FieldOffset(61)]
+                    public byte IsDependent;
+
+                    [FieldOffset(62)]
+                    public byte IsImplicit;
+
+                    [FieldOffset(64)]
+                    public global::System.IntPtr CompleteDeclaration;
+
+                    [FieldOffset(68)]
+                    public uint DefinitionOrder;
+
+                    [FieldOffset(84)]
+                    public global::System.IntPtr OriginalPtr;
+
+                    [FieldOffset(88)]
+                    public global::System.IntPtr Comment;
+
+                    [FieldOffset(92)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(108)]
+                    public byte IsParameterPack;
+
+                    [FieldOffset(109)]
+                    public byte IsPackExpansion;
+
+                    [FieldOffset(110)]
+                    public byte IsExpandedParameterPack;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2ERKS2_")]
+                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native.ToPointer(), skipVTables);
+                }
+
+                public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TemplateTemplateParameter.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(112);
+                    CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TemplateTemplateParameter(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TemplateTemplateParameter()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(112);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(112);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    if (ReferenceEquals(_0, null))
+                        throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
+                    var arg0 = _0.__Instance;
+                    Internal.cctor_1((__Instance + __PointerAdjustment), arg0);
+                }
+
+                protected override void Dispose(bool disposing)
+                {
+                    CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public bool IsParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsPackExpansion
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsPackExpansion != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsExpandedParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsExpandedParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+            }
+
             public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 112)]

src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/AST.cs

@@ -57,8 +57,9 @@ namespace CppSharp
                 MacroExpansion = 19,
                 TranslationUnit = 20,
                 Friend = 21,
-                TemplateTypeParm = 22,
+                TemplateTemplateParm = 22,
-                NonTypeTemplateParm = 23
+                TemplateTypeParm = 23,
+                NonTypeTemplateParm = 24
             }
 
             public enum AccessSpecifier
@@ -8060,6 +8061,181 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 148)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(12)]
+                    public CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(16)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(20)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(96)]
+                    public byte IsIncomplete;
+
+                    [FieldOffset(97)]
+                    public byte IsDependent;
+
+                    [FieldOffset(98)]
+                    public byte IsImplicit;
+
+                    [FieldOffset(100)]
+                    public global::System.IntPtr CompleteDeclaration;
+
+                    [FieldOffset(104)]
+                    public uint DefinitionOrder;
+
+                    [FieldOffset(120)]
+                    public global::System.IntPtr OriginalPtr;
+
+                    [FieldOffset(124)]
+                    public global::System.IntPtr Comment;
+
+                    [FieldOffset(128)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(144)]
+                    public byte IsParameterPack;
+
+                    [FieldOffset(145)]
+                    public byte IsPackExpansion;
+
+                    [FieldOffset(146)]
+                    public byte IsExpandedParameterPack;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??0TemplateTemplateParameter@AST@CppParser@CppSharp@@QAE@XZ")]
+                    internal static extern global::System.IntPtr ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??0TemplateTemplateParameter@AST@CppParser@CppSharp@@QAE@ABV0123@@Z")]
+                    internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??1TemplateTemplateParameter@AST@CppParser@CppSharp@@QAE@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+                }
+
+                public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native.ToPointer(), skipVTables);
+                }
+
+                public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TemplateTemplateParameter.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(148);
+                    CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TemplateTemplateParameter(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TemplateTemplateParameter()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(148);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(148);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    if (ReferenceEquals(_0, null))
+                        throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
+                    var arg0 = _0.__Instance;
+                    Internal.cctor_1((__Instance + __PointerAdjustment), arg0);
+                }
+
+                protected override void Dispose(bool disposing)
+                {
+                    CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public bool IsParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsPackExpansion
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsPackExpansion != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsExpandedParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsExpandedParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+            }
+
             public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 148)]

src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/AST.cs

@@ -57,8 +57,9 @@ namespace CppSharp
                 MacroExpansion = 19,
                 TranslationUnit = 20,
                 Friend = 21,
-                TemplateTypeParm = 22,
+                TemplateTemplateParm = 22,
-                NonTypeTemplateParm = 23
+                TemplateTypeParm = 23,
+                NonTypeTemplateParm = 24
             }
 
             public enum AccessSpecifier
@@ -8059,6 +8060,181 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 208)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(104)]
+                    public byte IsIncomplete;
+
+                    [FieldOffset(105)]
+                    public byte IsDependent;
+
+                    [FieldOffset(106)]
+                    public byte IsImplicit;
+
+                    [FieldOffset(112)]
+                    public global::System.IntPtr CompleteDeclaration;
+
+                    [FieldOffset(120)]
+                    public uint DefinitionOrder;
+
+                    [FieldOffset(152)]
+                    public global::System.IntPtr OriginalPtr;
+
+                    [FieldOffset(160)]
+                    public global::System.IntPtr Comment;
+
+                    [FieldOffset(168)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(200)]
+                    public byte IsParameterPack;
+
+                    [FieldOffset(201)]
+                    public byte IsPackExpansion;
+
+                    [FieldOffset(202)]
+                    public byte IsExpandedParameterPack;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2ERKS2_")]
+                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native.ToPointer(), skipVTables);
+                }
+
+                public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TemplateTemplateParameter.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(208);
+                    CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TemplateTemplateParameter(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TemplateTemplateParameter()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(208);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(208);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    if (ReferenceEquals(_0, null))
+                        throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
+                    var arg0 = _0.__Instance;
+                    Internal.cctor_1((__Instance + __PointerAdjustment), arg0);
+                }
+
+                protected override void Dispose(bool disposing)
+                {
+                    CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public bool IsParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsPackExpansion
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsPackExpansion != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsExpandedParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsExpandedParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+            }
+
             public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 200)]

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs

@@ -57,8 +57,9 @@ namespace CppSharp
                 MacroExpansion = 19,
                 TranslationUnit = 20,
                 Friend = 21,
-                TemplateTypeParm = 22,
+                TemplateTemplateParm = 22,
-                NonTypeTemplateParm = 23
+                TemplateTypeParm = 23,
+                NonTypeTemplateParm = 24
             }
 
             public enum AccessSpecifier
@@ -8059,6 +8060,181 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 160)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(56)]
+                    public byte IsIncomplete;
+
+                    [FieldOffset(57)]
+                    public byte IsDependent;
+
+                    [FieldOffset(58)]
+                    public byte IsImplicit;
+
+                    [FieldOffset(64)]
+                    public global::System.IntPtr CompleteDeclaration;
+
+                    [FieldOffset(72)]
+                    public uint DefinitionOrder;
+
+                    [FieldOffset(104)]
+                    public global::System.IntPtr OriginalPtr;
+
+                    [FieldOffset(112)]
+                    public global::System.IntPtr Comment;
+
+                    [FieldOffset(120)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(152)]
+                    public byte IsParameterPack;
+
+                    [FieldOffset(153)]
+                    public byte IsPackExpansion;
+
+                    [FieldOffset(154)]
+                    public byte IsExpandedParameterPack;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2ERKS2_")]
+                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native.ToPointer(), skipVTables);
+                }
+
+                public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TemplateTemplateParameter.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(160);
+                    CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TemplateTemplateParameter(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TemplateTemplateParameter()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(160);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(160);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    if (ReferenceEquals(_0, null))
+                        throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
+                    var arg0 = _0.__Instance;
+                    Internal.cctor_1((__Instance + __PointerAdjustment), arg0);
+                }
+
+                protected override void Dispose(bool disposing)
+                {
+                    CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public bool IsParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsPackExpansion
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsPackExpansion != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsExpandedParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsExpandedParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+            }
+
             public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 152)]

src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/AST.cs

@@ -57,8 +57,9 @@ namespace CppSharp
                 MacroExpansion = 19,
                 TranslationUnit = 20,
                 Friend = 21,
-                TemplateTypeParm = 22,
+                TemplateTemplateParm = 22,
-                NonTypeTemplateParm = 23
+                TemplateTypeParm = 23,
+                NonTypeTemplateParm = 24
             }
 
             public enum AccessSpecifier
@@ -8060,6 +8061,181 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 232)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(128)]
+                    public byte IsIncomplete;
+
+                    [FieldOffset(129)]
+                    public byte IsDependent;
+
+                    [FieldOffset(130)]
+                    public byte IsImplicit;
+
+                    [FieldOffset(136)]
+                    public global::System.IntPtr CompleteDeclaration;
+
+                    [FieldOffset(144)]
+                    public uint DefinitionOrder;
+
+                    [FieldOffset(176)]
+                    public global::System.IntPtr OriginalPtr;
+
+                    [FieldOffset(184)]
+                    public global::System.IntPtr Comment;
+
+                    [FieldOffset(192)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(224)]
+                    public byte IsParameterPack;
+
+                    [FieldOffset(225)]
+                    public byte IsPackExpansion;
+
+                    [FieldOffset(226)]
+                    public byte IsExpandedParameterPack;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="??0TemplateTemplateParameter@AST@CppParser@CppSharp@@QEAA@XZ")]
+                    internal static extern global::System.IntPtr ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="??0TemplateTemplateParameter@AST@CppParser@CppSharp@@QEAA@AEBV0123@@Z")]
+                    internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="??1TemplateTemplateParameter@AST@CppParser@CppSharp@@QEAA@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+                }
+
+                public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native.ToPointer(), skipVTables);
+                }
+
+                public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                {
+                    return new TemplateTemplateParameter(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TemplateTemplateParameter.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(232);
+                    CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TemplateTemplateParameter(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TemplateTemplateParameter()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(232);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(232);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    if (ReferenceEquals(_0, null))
+                        throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
+                    var arg0 = _0.__Instance;
+                    Internal.cctor_1((__Instance + __PointerAdjustment), arg0);
+                }
+
+                protected override void Dispose(bool disposing)
+                {
+                    CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public bool IsParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsPackExpansion
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsPackExpansion != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0);
+                    }
+                }
+
+                public bool IsExpandedParameterPack
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->IsExpandedParameterPack != 0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0);
+                    }
+                }
+            }
+
             public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 224)]

src/CppParser/Parser.cpp

@@ -397,7 +397,7 @@ static clang::SourceLocation GetDeclStartLocation(clang::CompilerInstance* C,
     auto startLoc = SM.getExpansionLoc(D->getLocStart());
     auto startOffset = SM.getFileOffset(startLoc);
 
-    if (clang::dyn_cast_or_null<clang::TranslationUnitDecl>(D))
+    if (clang::dyn_cast_or_null<clang::TranslationUnitDecl>(D) || !startLoc.isValid())
         return startLoc;
 
     auto lineNo = SM.getExpansionLineNumber(startLoc);
@@ -1008,6 +1008,24 @@ ClassTemplate* Parser::WalkClassTemplate(clang::ClassTemplateDecl* TD)
 
 //-----------------------------------//
 
+TemplateTemplateParameter* Parser::WalkTemplateTemplateParameter(clang::TemplateTemplateParmDecl* TTP)
+{
+    auto TP = new TemplateTemplateParameter();
+    HandleDeclaration(TTP, TP);
+    TP->Parameters = WalkTemplateParameterList(TTP->getTemplateParameters());
+    TP->IsParameterPack = TTP->isParameterPack();
+    TP->IsPackExpansion = TTP->isPackExpansion();
+    TP->IsExpandedParameterPack = TTP->isExpandedParameterPack();
+    if (TTP->getTemplatedDecl())
+    {
+        auto TD = WalkDeclaration(TTP->getTemplatedDecl(), /*IgnoreSystemDecls=*/false);
+        TP->TemplatedDecl = TD;
+    }
+    return TP;
+}
+
+//-----------------------------------//
+
 TypeTemplateParameter* Parser::WalkTypeTemplateParameter(clang::TemplateTypeParmDecl* TTPD)
 {
     using namespace clang;
@@ -2917,17 +2935,20 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
     if (IgnoreSystemDecls && !IsValidDeclaration(D->getLocation()))
         return nullptr;
 
-    for(auto it = D->attr_begin(); it != D->attr_end(); ++it)
+    if (D->hasAttrs())
     {
-        Attr* Attr = (*it);
+        for (auto it = D->attr_begin(); it != D->attr_end(); ++it)
+        {
+            Attr* Attr = (*it);
 
-        if(Attr->getKind() != clang::attr::Annotate)
+            if (Attr->getKind() != clang::attr::Annotate)
-            continue;
+                continue;
 
-        AnnotateAttr* Annotation = cast<AnnotateAttr>(Attr);
+            AnnotateAttr* Annotation = cast<AnnotateAttr>(Attr);
-        assert(Annotation != nullptr);
+            assert(Annotation != nullptr);
 
-        StringRef AnnotationText = Annotation->getAnnotation();
+            StringRef AnnotationText = Annotation->getAnnotation();
+        }
     }
 
     Declaration* Decl = nullptr;
@@ -3101,6 +3122,12 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
         Decl = WalkFriend(FD);
         break;
     }
+    case Decl::TemplateTemplateParm:
+    {
+        auto TTP = cast<TemplateTemplateParmDecl>(D);
+        Decl = WalkTemplateTemplateParameter(TTP);
+        break;
+    }
     case Decl::TemplateTypeParm:
     {
         auto TTPD = cast<TemplateTypeParmDecl>(D);

src/CppParser/Parser.h

@@ -88,6 +88,7 @@ protected:
     Type* WalkType(clang::QualType QualType, clang::TypeLoc* TL = 0,
       bool DesugarType = false);
     TemplateArgument WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateArgumentLoc* ArgLoc);
+    TemplateTemplateParameter* WalkTemplateTemplateParameter(clang::TemplateTemplateParmDecl* TTP);
     TypeTemplateParameter* WalkTypeTemplateParameter(clang::TemplateTypeParmDecl* TTPD);
     NonTypeTemplateParameter* WalkNonTypeTemplateParameter(clang::NonTypeTemplateParmDecl* TTPD);
     std::vector<Declaration*> WalkTemplateParameterList(const clang::TemplateParameterList* TPL);

src/Generator.Tests/AST/TestAST.cs

@@ -151,12 +151,17 @@ namespace CppSharp.Generator.Tests.AST
                 throw new System.NotImplementedException();
             }
 
-            public bool VisitTemplateParameter(TypeTemplateParameter templateParameter)
+            public bool VisitTemplateParameterDecl(TypeTemplateParameter templateParameter)
             {
                 throw new NotImplementedException();
             }
 
-            public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+            public bool VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter)
+            {
+                throw new NotImplementedException();
+            }
+
+            public bool VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter)
             {
                 throw new NotImplementedException();
             }

src/Generator/Generators/CLI/CLITypePrinter.cs

@@ -430,12 +430,17 @@ namespace CppSharp.Generators.CLI
             return type.Visit(this);
         }
 
-        public string VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        public string VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter)
+        {
+            return templateTemplateParameter.Name;
+        }
+
+        public string VisitTemplateParameterDecl(TypeTemplateParameter templateParameter)
         {
             return templateParameter.Name;
         }
 
-        public string VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        public string VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter)
         {
             return nonTypeTemplateParameter.Name;
         }

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -727,12 +727,17 @@ namespace CppSharp.Generators.CSharp
             return type.Visit(this).Type;
         }
 
-        public CSharpTypePrinterResult VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        public CSharpTypePrinterResult VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter)
+        {
+            return templateTemplateParameter.Name;
+        }
+
+        public CSharpTypePrinterResult VisitTemplateParameterDecl(TypeTemplateParameter templateParameter)
         {
             return templateParameter.Name;
         }
 
-        public CSharpTypePrinterResult VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        public CSharpTypePrinterResult VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter)
         {
             return nonTypeTemplateParameter.Name;
         }

src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs

@@ -1,4 +1,5 @@
-using CppSharp.AST;
+using System;
+using CppSharp.AST;
 using CppSharp.AST.Extensions;
 
 namespace CppSharp.Passes
@@ -242,12 +243,17 @@ namespace CppSharp.Passes
             return false;
         }
 
-        public bool VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        public bool VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter)
         {
             return false;
         }
 
-        public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        public bool VisitTemplateParameterDecl(TypeTemplateParameter templateParameter)
+        {
+            return false;
+        }
+
+        public bool VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter)
         {
             return false;
         }

src/Generator/Passes/GenerateAnonymousDelegatesPass.cs

@@ -63,6 +63,9 @@ namespace CppSharp.Passes
         /// <returns>The new type.</returns>
         private QualifiedType CheckType(DeclarationContext @namespace, QualifiedType type)
         {
+            if (type.Type.IsDependent)
+                return type;
+
             var pointerType = type.Type as PointerType;
             if (pointerType == null)
                 return type;

src/Generator/Types/CppTypePrinter.cs

@@ -150,6 +150,9 @@ namespace CppSharp.Types
 
         public string VisitTemplateSpecializationType(TemplateSpecializationType template, TypeQualifiers quals)
         {
+            if (template.Template.TemplatedDecl == null)
+                return string.Empty;
+
             return string.Format("{0}<{1}>", template.Template.TemplatedDecl.Visit(this),
                 string.Join(", ",
                 template.Arguments.Where(
@@ -343,7 +346,12 @@ namespace CppSharp.Types
             return type.Visit(this);
         }
 
-        public string VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        public string VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter)
+        {
+            return templateTemplateParameter.Name;
+        }
+
+        public string VisitTemplateParameterDecl(TypeTemplateParameter templateParameter)
         {
             if (templateParameter.DefaultArgument.Type == null)
                 return templateParameter.Name;
@@ -352,7 +360,7 @@ namespace CppSharp.Types
                 templateParameter.DefaultArgument.Visit(this));
         }
 
-        public string VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        public string VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter)
         {
             if (nonTypeTemplateParameter.DefaultArgument == null)
                 return nonTypeTemplateParameter.Name;

src/Generator/Types/TypeMap.cs

@@ -199,7 +199,7 @@ namespace CppSharp.Types
             var typePrinter = new CppTypePrinter();
 
             var template = type as TemplateSpecializationType;
-            if (template != null)
+            if (template != null && template.Template.TemplatedDecl != null)
                 return FindTypeMap(template.Template.TemplatedDecl, type,
                     out typeMap);
 

tests/CSharp/CSharpTemplates.h

@@ -91,3 +91,30 @@ class PartiallySpecialized<Key, int>
         float f;
     };
 };
+
+template<class T>
+class HasResultType {
+    typedef char Yes;
+    typedef void *No;
+    template<typename U> static Yes test(int, const typename U::result_type * = 0);
+    template<typename U> static No test(double);
+public:
+    enum { Value = (sizeof(test<T>(0)) == sizeof(Yes)) };
+};
+
+template <typename Functor, bool foo = HasResultType<Functor>::Value>
+struct LazyResultType { typedef typename Functor::result_type Type; };
+template <typename Functor>
+struct LazyResultType<Functor, false> { typedef void Type; };
+
+template <class InputSequence, class MapFunctor>
+struct MapResultType
+{
+    typedef typename LazyResultType<MapFunctor>::Type ResultType;
+};
+
+template <template <typename> class InputSequence, typename MapFunctor, typename T>
+struct MapResultType<InputSequence<T>, MapFunctor>
+{
+    typedef InputSequence<typename LazyResultType<MapFunctor>::Type> ResultType;
+};