Added support for C++11 type alias template declarations.

Partial fix for https://github.com/mono/CppSharp/issues/664.

src/AST/ASTVisitor.cs

@@ -372,6 +372,17 @@ namespace CppSharp.AST
             return true;
         }
 
+        public virtual bool VisitTypeAliasTemplateDecl(TypeAliasTemplate template)
+        {
+            if (!VisitDeclaration(template))
+                return false;
+
+            foreach (var templateParameter in template.Parameters)
+                templateParameter.Visit(this);
+
+            return true;
+        }
+
         public virtual bool VisitClassTemplateDecl(ClassTemplate template)
         {
             if (!VisitDeclaration(template))

src/AST/Declaration.cs

@@ -389,5 +389,6 @@ namespace CppSharp.AST
         T VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter);
         T VisitTemplateParameterDecl(TypeTemplateParameter templateParameter);
         T VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter);
+        T VisitTypeAliasTemplateDecl(TypeAliasTemplate typeAliasTemplate);
     }
 }

src/AST/Template.cs

@@ -174,6 +174,17 @@ namespace CppSharp.AST
         }
     }
 
+    /// <summary>
+    /// Declaration of a type alias template.
+    /// </summary>
+    public class TypeAliasTemplate : Template
+    {
+        public override T Visit<T>(IDeclVisitor<T> visitor)
+        {
+            return visitor.VisitTypeAliasTemplateDecl(this);
+        }
+    }
+
     /// <summary>
     /// Declaration of a class template.
     /// </summary>

src/Core/Parser/ASTConverter.cs

@@ -133,6 +133,7 @@ namespace CppSharp
         public abstract TRet VisitField(Field decl);
         public abstract TRet VisitAccessSpecifier(AccessSpecifierDecl decl);
         public abstract TRet VisitClass(Class decl);
+        public abstract TRet VisitTypeAliasTemplate(TypeAliasTemplate decl);
         public abstract TRet VisitClassTemplate(ClassTemplate decl);
         public abstract TRet VisitClassTemplateSpecialization(
             ClassTemplateSpecialization decl);
@@ -232,6 +233,11 @@ namespace CppSharp
                         var _decl = FunctionTemplate.__CreateInstance(decl.__Instance);
                         return VisitFunctionTemplate(_decl);
                     }
+                case DeclarationKind.TypeAliasTemplate:
+                    {
+                        var _decl = TypeAliasTemplate.__CreateInstance(decl.__Instance);
+                        return VisitTypeAliasTemplate(_decl);
+                    }
                 case DeclarationKind.TemplateTemplateParm:
                     {
                         var _decl = TemplateTemplateParameter.__CreateInstance(decl.__Instance);
@@ -1469,6 +1475,14 @@ namespace CppSharp
             }
         }
 
+        public override AST.Declaration VisitTypeAliasTemplate(TypeAliasTemplate decl)
+        {
+            var _decl = new AST.TypeAliasTemplate();
+            VisitTemplate(decl, _decl);
+
+            return _decl;
+        }
+
         public override AST.Declaration VisitClassTemplate(ClassTemplate decl)
         {
             var _decl = new AST.ClassTemplate();

src/CppParser/AST.cpp

@@ -84,8 +84,6 @@ AttributedType::AttributedType() : Type(TypeKind::Attributed) {}
 DecayedType::DecayedType() : Type(TypeKind::Decayed) {}
 
 // Template
-Template::Template(DeclarationKind kind) : Declaration(kind) {}
-
 TemplateParameter::TemplateParameter(DeclarationKind kind)
     : Declaration(kind)
     , Depth(0)
@@ -460,7 +458,7 @@ Function* DeclarationContext::FindFunction(const std::string& USR)
         return *foundFunction;
 
     auto foundTemplate = std::find_if(Templates.begin(), Templates.end(),
-        [&](Template* t) { return t->TemplatedDecl->USR == USR; });
+        [&](Template* t) { return t->TemplatedDecl && t->TemplatedDecl->USR == USR; });
 
     if (foundTemplate != Templates.end())
         return static_cast<Function*>((*foundTemplate)->TemplatedDecl);
@@ -480,6 +478,19 @@ DeclarationContext::FindClassTemplate(const std::string& USR)
     return nullptr;
 }
 
+TypeAliasTemplate*
+DeclarationContext::FindTypeAliasTemplate(const std::string& USR)
+{
+    auto foundTemplate = std::find_if(Templates.begin(), Templates.end(),
+        [&](Template* t) { return t->USR == USR; }
+    );
+
+    if (foundTemplate != Templates.end())
+        return static_cast<TypeAliasTemplate*>(*foundTemplate);
+
+    return nullptr;
+}
+
 FunctionTemplate*
 DeclarationContext::FindFunctionTemplate(const std::string& USR)
 {
@@ -712,8 +723,14 @@ DEF_VECTOR(Class, AccessSpecifierDecl*, Specifiers)
 Template::Template() : Declaration(DeclarationKind::Template),
     TemplatedDecl(0) {}
 
+Template::Template(DeclarationKind kind) : Declaration(kind), TemplatedDecl(0) {}
+
 DEF_VECTOR(Template, Declaration*, Parameters)
 
+TypeAliasTemplate::TypeAliasTemplate() : Template(DeclarationKind::TypeAliasTemplate) {}
+
+TypeAliasTemplate::~TypeAliasTemplate() {}
+
 ClassTemplate::ClassTemplate() : Template(DeclarationKind::ClassTemplate) {}
 
 ClassTemplate::~ClassTemplate() {}

src/CppParser/AST.h

@@ -372,6 +372,7 @@ enum class DeclarationKind
     AccessSpecifier,
     Class,
     Template,
+    TypeAliasTemplate,
     ClassTemplate,
     ClassTemplateSpecialization,
     ClassTemplatePartialSpecialization,
@@ -433,6 +434,7 @@ class Function;
 class TypedefDecl;
 class Namespace;
 class Template;
+class TypeAliasTemplate;
 class ClassTemplate;
 class FunctionTemplate;
 class Variable;
@@ -454,6 +456,7 @@ public:
     CS_IGNORE Class* FindClass(const std::string& Name, bool IsComplete,
         bool Create);
 
+    CS_IGNORE TypeAliasTemplate* FindTypeAliasTemplate(const std::string& USR);
     CS_IGNORE ClassTemplate* FindClassTemplate(const std::string& USR);
     CS_IGNORE FunctionTemplate* FindFunctionTemplate(const std::string& USR);
 
@@ -777,6 +780,13 @@ public:
     VECTOR(Declaration*, Parameters)
 };
 
+class CS_API TypeAliasTemplate : public Template
+{
+public:
+    TypeAliasTemplate();
+    ~TypeAliasTemplate();
+};
+
 class CS_API TemplateParameter : public Declaration
 {
 public:

src/CppParser/Bindings/CLI/AST.cpp

@@ -3651,6 +3651,43 @@ void CppSharp::Parser::AST::Template::TemplatedDecl::set(CppSharp::Parser::AST::
     ((::CppSharp::CppParser::AST::Template*)NativePtr)->TemplatedDecl = (::CppSharp::CppParser::AST::Declaration*)value->NativePtr;
 }
 
+CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate(::CppSharp::CppParser::AST::TypeAliasTemplate* native)
+    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
+{
+}
+
+CppSharp::Parser::AST::TypeAliasTemplate^ CppSharp::Parser::AST::TypeAliasTemplate::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::AST::TypeAliasTemplate((::CppSharp::CppParser::AST::TypeAliasTemplate*) native.ToPointer());
+}
+
+CppSharp::Parser::AST::TypeAliasTemplate::~TypeAliasTemplate()
+{
+    if (NativePtr)
+    {
+        auto __nativePtr = NativePtr;
+        NativePtr = 0;
+        delete (::CppSharp::CppParser::AST::TypeAliasTemplate*) __nativePtr;
+    }
+}
+
+CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate()
+    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
+{
+    __ownsNativeInstance = true;
+    NativePtr = new ::CppSharp::CppParser::AST::TypeAliasTemplate();
+}
+
+CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate(CppSharp::Parser::AST::TypeAliasTemplate^ _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::TypeAliasTemplate*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::TypeAliasTemplate(__arg0);
+}
+
 CppSharp::Parser::AST::TemplateParameter::TemplateParameter(::CppSharp::CppParser::AST::TemplateParameter* native)
     : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
 {

src/CppParser/Bindings/CLI/AST.h

@@ -91,6 +91,7 @@ namespace CppSharp
             ref class TextComment;
             ref class TranslationUnit;
             ref class Type;
+            ref class TypeAliasTemplate;
             ref class TypeQualifiers;
             ref class TypeTemplateParameter;
             ref class TypedefDecl;
@@ -145,19 +146,20 @@ namespace CppSharp
                 AccessSpecifier = 9,
                 Class = 10,
                 Template = 11,
-                ClassTemplate = 12,
-                ClassTemplateSpecialization = 13,
-                ClassTemplatePartialSpecialization = 14,
-                FunctionTemplate = 15,
-                Namespace = 16,
-                PreprocessedEntity = 17,
-                MacroDefinition = 18,
-                MacroExpansion = 19,
-                TranslationUnit = 20,
-                Friend = 21,
-                TemplateTemplateParm = 22,
-                TemplateTypeParm = 23,
-                NonTypeTemplateParm = 24
+                TypeAliasTemplate = 12,
+                ClassTemplate = 13,
+                ClassTemplateSpecialization = 14,
+                ClassTemplatePartialSpecialization = 15,
+                FunctionTemplate = 16,
+                Namespace = 17,
+                PreprocessedEntity = 18,
+                MacroDefinition = 19,
+                MacroExpansion = 20,
+                TranslationUnit = 21,
+                Friend = 22,
+                TemplateTemplateParm = 23,
+                TemplateTypeParm = 24,
+                NonTypeTemplateParm = 25
             };
 
             public enum struct AccessSpecifier
@@ -2170,6 +2172,19 @@ namespace CppSharp
                 void clearParameters();
             };
 
+            public ref class TypeAliasTemplate : CppSharp::Parser::AST::Template
+            {
+            public:
+
+                TypeAliasTemplate(::CppSharp::CppParser::AST::TypeAliasTemplate* native);
+                static TypeAliasTemplate^ __CreateInstance(::System::IntPtr native);
+                TypeAliasTemplate();
+
+                TypeAliasTemplate(CppSharp::Parser::AST::TypeAliasTemplate^ _0);
+
+                ~TypeAliasTemplate();
+            };
+
             public ref class TemplateParameter : CppSharp::Parser::AST::Declaration
             {
             public:

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

@@ -47,19 +47,20 @@ namespace CppSharp
                 AccessSpecifier = 9,
                 Class = 10,
                 Template = 11,
-                ClassTemplate = 12,
-                ClassTemplateSpecialization = 13,
-                ClassTemplatePartialSpecialization = 14,
-                FunctionTemplate = 15,
-                Namespace = 16,
-                PreprocessedEntity = 17,
-                MacroDefinition = 18,
-                MacroExpansion = 19,
-                TranslationUnit = 20,
-                Friend = 21,
-                TemplateTemplateParm = 22,
-                TemplateTypeParm = 23,
-                NonTypeTemplateParm = 24
+                TypeAliasTemplate = 12,
+                ClassTemplate = 13,
+                ClassTemplateSpecialization = 14,
+                ClassTemplatePartialSpecialization = 15,
+                FunctionTemplate = 16,
+                Namespace = 17,
+                PreprocessedEntity = 18,
+                MacroDefinition = 19,
+                MacroExpansion = 20,
+                TranslationUnit = 21,
+                Friend = 22,
+                TemplateTemplateParm = 23,
+                TemplateTypeParm = 24,
+                NonTypeTemplateParm = 25
             }
 
             public enum AccessSpecifier
@@ -8269,6 +8270,133 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TypeAliasTemplate : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 108)]
+                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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new TypeAliasTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static TypeAliasTemplate __CreateInstance(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TypeAliasTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(108);
+                    CppSharp.Parser.AST.TypeAliasTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TypeAliasTemplate(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TypeAliasTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TypeAliasTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(108);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TypeAliasTemplate(CppSharp.Parser.AST.TypeAliasTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(108);
+                    __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 unsafe partial class TemplateParameter : CppSharp.Parser.AST.Declaration, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 104)]

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

@@ -47,19 +47,20 @@ namespace CppSharp
                 AccessSpecifier = 9,
                 Class = 10,
                 Template = 11,
-                ClassTemplate = 12,
-                ClassTemplateSpecialization = 13,
-                ClassTemplatePartialSpecialization = 14,
-                FunctionTemplate = 15,
-                Namespace = 16,
-                PreprocessedEntity = 17,
-                MacroDefinition = 18,
-                MacroExpansion = 19,
-                TranslationUnit = 20,
-                Friend = 21,
-                TemplateTemplateParm = 22,
-                TemplateTypeParm = 23,
-                NonTypeTemplateParm = 24
+                TypeAliasTemplate = 12,
+                ClassTemplate = 13,
+                ClassTemplateSpecialization = 14,
+                ClassTemplatePartialSpecialization = 15,
+                FunctionTemplate = 16,
+                Namespace = 17,
+                PreprocessedEntity = 18,
+                MacroDefinition = 19,
+                MacroExpansion = 20,
+                TranslationUnit = 21,
+                Friend = 22,
+                TemplateTemplateParm = 23,
+                TemplateTypeParm = 24,
+                NonTypeTemplateParm = 25
             }
 
             public enum AccessSpecifier
@@ -8269,6 +8270,133 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TypeAliasTemplate : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 144)]
+                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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??0TypeAliasTemplate@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="??0TypeAliasTemplate@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="??1TypeAliasTemplate@AST@CppParser@CppSharp@@QAE@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+                }
+
+                public static new TypeAliasTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static TypeAliasTemplate __CreateInstance(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TypeAliasTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(144);
+                    CppSharp.Parser.AST.TypeAliasTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TypeAliasTemplate(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TypeAliasTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TypeAliasTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(144);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TypeAliasTemplate(CppSharp.Parser.AST.TypeAliasTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(144);
+                    __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 unsafe partial class TemplateParameter : CppSharp.Parser.AST.Declaration, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 140)]

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

@@ -47,19 +47,20 @@ namespace CppSharp
                 AccessSpecifier = 9,
                 Class = 10,
                 Template = 11,
-                ClassTemplate = 12,
-                ClassTemplateSpecialization = 13,
-                ClassTemplatePartialSpecialization = 14,
-                FunctionTemplate = 15,
-                Namespace = 16,
-                PreprocessedEntity = 17,
-                MacroDefinition = 18,
-                MacroExpansion = 19,
-                TranslationUnit = 20,
-                Friend = 21,
-                TemplateTemplateParm = 22,
-                TemplateTypeParm = 23,
-                NonTypeTemplateParm = 24
+                TypeAliasTemplate = 12,
+                ClassTemplate = 13,
+                ClassTemplateSpecialization = 14,
+                ClassTemplatePartialSpecialization = 15,
+                FunctionTemplate = 16,
+                Namespace = 17,
+                PreprocessedEntity = 18,
+                MacroDefinition = 19,
+                MacroExpansion = 20,
+                TranslationUnit = 21,
+                Friend = 22,
+                TemplateTemplateParm = 23,
+                TemplateTypeParm = 24,
+                NonTypeTemplateParm = 25
             }
 
             public enum AccessSpecifier
@@ -8268,6 +8269,133 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TypeAliasTemplate : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 200)]
+                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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new TypeAliasTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static TypeAliasTemplate __CreateInstance(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TypeAliasTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(200);
+                    CppSharp.Parser.AST.TypeAliasTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TypeAliasTemplate(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TypeAliasTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TypeAliasTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(200);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TypeAliasTemplate(CppSharp.Parser.AST.TypeAliasTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(200);
+                    __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 unsafe partial class TemplateParameter : CppSharp.Parser.AST.Declaration, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 184)]

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

@@ -47,19 +47,20 @@ namespace CppSharp
                 AccessSpecifier = 9,
                 Class = 10,
                 Template = 11,
-                ClassTemplate = 12,
-                ClassTemplateSpecialization = 13,
-                ClassTemplatePartialSpecialization = 14,
-                FunctionTemplate = 15,
-                Namespace = 16,
-                PreprocessedEntity = 17,
-                MacroDefinition = 18,
-                MacroExpansion = 19,
-                TranslationUnit = 20,
-                Friend = 21,
-                TemplateTemplateParm = 22,
-                TemplateTypeParm = 23,
-                NonTypeTemplateParm = 24
+                TypeAliasTemplate = 12,
+                ClassTemplate = 13,
+                ClassTemplateSpecialization = 14,
+                ClassTemplatePartialSpecialization = 15,
+                FunctionTemplate = 16,
+                Namespace = 17,
+                PreprocessedEntity = 18,
+                MacroDefinition = 19,
+                MacroExpansion = 20,
+                TranslationUnit = 21,
+                Friend = 22,
+                TemplateTemplateParm = 23,
+                TemplateTypeParm = 24,
+                NonTypeTemplateParm = 25
             }
 
             public enum AccessSpecifier
@@ -8268,6 +8269,133 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TypeAliasTemplate : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 152)]
+                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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST17TypeAliasTemplateD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new TypeAliasTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static TypeAliasTemplate __CreateInstance(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TypeAliasTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(152);
+                    CppSharp.Parser.AST.TypeAliasTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TypeAliasTemplate(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TypeAliasTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TypeAliasTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(152);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TypeAliasTemplate(CppSharp.Parser.AST.TypeAliasTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(152);
+                    __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 unsafe partial class TemplateParameter : CppSharp.Parser.AST.Declaration, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 136)]

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

@@ -47,19 +47,20 @@ namespace CppSharp
                 AccessSpecifier = 9,
                 Class = 10,
                 Template = 11,
-                ClassTemplate = 12,
-                ClassTemplateSpecialization = 13,
-                ClassTemplatePartialSpecialization = 14,
-                FunctionTemplate = 15,
-                Namespace = 16,
-                PreprocessedEntity = 17,
-                MacroDefinition = 18,
-                MacroExpansion = 19,
-                TranslationUnit = 20,
-                Friend = 21,
-                TemplateTemplateParm = 22,
-                TemplateTypeParm = 23,
-                NonTypeTemplateParm = 24
+                TypeAliasTemplate = 12,
+                ClassTemplate = 13,
+                ClassTemplateSpecialization = 14,
+                ClassTemplatePartialSpecialization = 15,
+                FunctionTemplate = 16,
+                Namespace = 17,
+                PreprocessedEntity = 18,
+                MacroDefinition = 19,
+                MacroExpansion = 20,
+                TranslationUnit = 21,
+                Friend = 22,
+                TemplateTemplateParm = 23,
+                TemplateTypeParm = 24,
+                NonTypeTemplateParm = 25
             }
 
             public enum AccessSpecifier
@@ -8269,6 +8270,133 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class TypeAliasTemplate : CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 224)]
+                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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="??0TypeAliasTemplate@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="??0TypeAliasTemplate@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="??1TypeAliasTemplate@AST@CppParser@CppSharp@@QEAA@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+                }
+
+                public static new TypeAliasTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static TypeAliasTemplate __CreateInstance(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new TypeAliasTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(TypeAliasTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(224);
+                    CppSharp.Parser.AST.TypeAliasTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private TypeAliasTemplate(TypeAliasTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected TypeAliasTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public TypeAliasTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(224);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public TypeAliasTemplate(CppSharp.Parser.AST.TypeAliasTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(224);
+                    __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 unsafe partial class TemplateParameter : CppSharp.Parser.AST.Declaration, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 208)]

src/CppParser/Parser.cpp

@@ -1278,6 +1278,36 @@ Parser::WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateA
 
 //-----------------------------------//
 
+TypeAliasTemplate* Parser::WalkTypeAliasTemplate(
+    const clang::TypeAliasTemplateDecl* TD)
+{
+    using namespace clang;
+
+    auto NS = GetNamespace(TD);
+    assert(NS && "Expected a valid namespace");
+
+    auto USR = GetDeclUSR(TD);
+    auto TA = NS->FindTypeAliasTemplate(USR);
+    if (TA != nullptr)
+        return TA;
+
+    // TODO: Add this when we add TypeAliasDecl to AST.
+    //auto TemplatedDecl = TD->getTemplatedDecl();
+
+    TA = new TypeAliasTemplate();
+    HandleDeclaration(TD, TA);
+
+    TA->Name = GetDeclName(TD);
+    //TA->TemplatedDecl = TAD;
+    TA->Parameters = WalkTemplateParameterList(TD->getTemplateParameters());
+
+    NS->Templates.push_back(TA);
+
+    return TA;
+}
+
+//-----------------------------------//
+
 FunctionTemplate* Parser::WalkFunctionTemplate(const clang::FunctionTemplateDecl* TD)
 {
     using namespace clang;
@@ -3146,6 +3176,14 @@ Declaration* Parser::WalkDeclaration(const clang::Decl* D,
         Decl = FT;
         break;
     }
+    case Decl::TypeAliasTemplate:
+    {
+        auto TD = cast<TypeAliasTemplateDecl>(D);
+        auto TA = WalkTypeAliasTemplate(TD);
+
+        Decl = TA;
+        break;
+    }
     case Decl::Enum:
     {
         auto ED = cast<EnumDecl>(D);
@@ -3268,8 +3306,6 @@ Declaration* Parser::WalkDeclaration(const clang::Decl* D,
     case Decl::UnresolvedUsingValue:
     case Decl::IndirectField:
     case Decl::StaticAssert:
-    case Decl::TypeAliasTemplate:
-        break;
     default:
     {
         Debug("Unhandled declaration kind: %s\n", D->getDeclKindName());

src/CppParser/Parser.h

@@ -92,6 +92,7 @@ private:
     TypeTemplateParameter* WalkTypeTemplateParameter(const clang::TemplateTypeParmDecl* TTPD);
     NonTypeTemplateParameter* WalkNonTypeTemplateParameter(const clang::NonTypeTemplateParmDecl* TTPD);
     std::vector<Declaration*> WalkTemplateParameterList(const clang::TemplateParameterList* TPL);
+    TypeAliasTemplate* WalkTypeAliasTemplate(const clang::TypeAliasTemplateDecl* TD);
     ClassTemplate* WalkClassTemplate(const clang::ClassTemplateDecl* TD);
     FunctionTemplate* WalkFunctionTemplate(const clang::FunctionTemplateDecl* TD);
     std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, clang::TemplateSpecializationTypeLoc* TSTL);

src/Generator.Tests/AST/TestAST.cs

@@ -165,6 +165,11 @@ namespace CppSharp.Generator.Tests.AST
             {
                 throw new NotImplementedException();
             }
+
+            public bool VisitTypeAliasTemplateDecl(TypeAliasTemplate typeAliasTemplate)
+            {
+                throw new NotImplementedException();
+            }
         }
         #endregion
 

src/Generator/Generators/CLI/CLITypePrinter.cs

@@ -444,5 +444,10 @@ namespace CppSharp.Generators.CLI
         {
             return nonTypeTemplateParameter.Name;
         }
+
+        public string VisitTypeAliasTemplateDecl(TypeAliasTemplate typeAliasTemplate)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -754,6 +754,11 @@ namespace CppSharp.Generators.CSharp
         {
             return nonTypeTemplateParameter.Name;
         }
+
+        public CSharpTypePrinterResult VisitTypeAliasTemplateDecl(TypeAliasTemplate typeAliasTemplate)
+        {
+            throw new NotImplementedException();
+        }
     }
 
     public static class CSharpTypePrinterExtensions

src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs

@@ -258,6 +258,11 @@ namespace CppSharp.Passes
             return false;
         }
 
+        public bool VisitTypeAliasTemplateDecl(TypeAliasTemplate typeAliasTemplate)
+        {
+            return false;
+        }
+
         #endregion
     }
 

src/Generator/Types/CppTypePrinter.cs

@@ -368,5 +368,10 @@ namespace CppSharp.Types
             return string.Format("{0} = {1}",  nonTypeTemplateParameter.Name,
                 nonTypeTemplateParameter.DefaultArgument.String);
         }
+
+        public string VisitTypeAliasTemplateDecl(TypeAliasTemplate typeAliasTemplate)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

tests/Common/Common.cpp

@@ -622,3 +622,8 @@ void HasProtectedEnum::function(ProtectedEnum param)
 void FuncWithTypeAlias(custom_int_t i)
 {
 }
+
+void FuncWithTemplateTypeAlias(TypeAliasTemplate<int> i)
+{
+
+}

tests/Common/Common.h

@@ -1104,7 +1104,11 @@ protected:
 };
 
 using custom_int_t = int;
-void FuncWithTypeAlias(custom_int_t i);
+DLL_API void FuncWithTypeAlias(custom_int_t i);
+
+template<typename T>
+using TypeAliasTemplate = TemplateWithVirtual<T>;
+DLL_API void FuncWithTemplateTypeAlias(TypeAliasTemplate<int> i);
 
 struct TestsTypes
 {