Fixed the wrapping of template parameters in the parser.

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

src/AST/ASTVisitor.cs

@@ -374,14 +374,20 @@ namespace CppSharp.AST
             if (!VisitDeclaration(template))
                 return false;
 
+            foreach (var templateParameter in template.Parameters)
+                templateParameter.Visit(this);
+
             return true;
         }
 
         public virtual bool VisitFunctionTemplateDecl(FunctionTemplate template)
         {
             if (!VisitDeclaration(template))
-                return false; 
-            
+                return false;
+
+            foreach (var templateParameter in template.Parameters)
+                templateParameter.Visit(this);
+
             return template.TemplatedFunction.Visit(this);
         }
 
@@ -443,6 +449,22 @@ namespace CppSharp.AST
             return true;
         }
 
+        public virtual bool VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        {
+            if (!VisitDeclaration(templateParameter))
+                return false;
+
+            return true;
+        }
+
+        public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        {
+            if (!VisitDeclaration(nonTypeTemplateParameter))
+                return false;
+
+            return true;
+        }
+
         #endregion
     }
 }

src/AST/Declaration.cs

@@ -391,5 +391,7 @@ namespace CppSharp.AST
         T VisitEvent(Event @event);
         T VisitProperty(Property @property);
         T VisitFriend(Friend friend);
+        T VisitTemplateParameter(TypeTemplateParameter templateParameter);
+        T VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter);
     }
 }

src/AST/Template.cs

@@ -1,22 +1,86 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace CppSharp.AST
 {
+    public abstract class TemplateParameter : 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; }
+    }
+
     /// <summary>
     /// Represents a template parameter
     /// </summary>
-    public struct TemplateParameter
+    public class TypeTemplateParameter : TemplateParameter
     {
-        public string Name;
-
         // Generic type constraint
         public string Constraint;
 
-        // Whether the template parameter represents a type parameter,
-        // like "T" in template<typename T>.
-        public bool IsTypeParameter;
+        public QualifiedType DefaultArgument { get; set; }
+
+        public override T Visit<T>(IDeclVisitor<T> visitor)
+        {
+            return visitor.VisitTemplateParameter(this);
+        }
+    }
+
+    /// <summary>
+    /// Represents a hard-coded template parameter
+    /// </summary>
+    public class NonTypeTemplateParameter : TemplateParameter
+    {
+        public Expression DefaultArgument { get; set; }
+
+        /// <summary>
+        /// Get the position of the template parameter within its parameter list.
+        /// </summary>
+        public uint Position { get; set; }
+
+        /// <summary>
+        /// Whether this parameter pack is a pack expansion.
+        /// <para>
+        /// A non-type template parameter pack is a pack expansion if its type contains an unexpanded parameter pack.In this case, we will have built a PackExpansionType wrapping the type.
+        /// </para>
+        /// </summary>
+        public bool IsPackExpansion { get; set; }
+
+        /// <summary>
+        /// Whether this parameter is a non-type template parameter pack that has a known list of different types at different positions.
+        /// <para>A parameter pack is an expanded parameter pack when the original parameter pack's type was itself a pack expansion, and that expansion has already been expanded. For example, given:</para>
+        /// <para>
+        /// template&lt;typename...Types&gt;
+        /// struct X {
+        ///   template&lt;Types...Values&gt;
+        ///   struct Y { /* ... */ };
+        /// };
+        /// </para>
+        /// The parameter pack Values has a PackExpansionType as its type, which expands Types.When Types is supplied with template arguments by instantiating X,
+        /// the instantiation of Values becomes an expanded parameter pack.For example, instantiating X&lt;int, unsigned int&gt;
+        /// results in Values being an expanded parameter pack with expansion types int and unsigned int.
+        /// </summary>
+        public bool IsExpandedParameterPack { get; set; }
+
+        public override T Visit<T>(IDeclVisitor<T> visitor)
+        {
+            return visitor.VisitNonTypeTemplateParameter(this);
+        }
     }
 
     /// <summary>

src/AST/Type.cs

@@ -665,7 +665,7 @@ namespace CppSharp.AST
     /// </summary>
     public class TemplateParameterType : Type
     {
-        public TemplateParameter Parameter;
+        public TypeTemplateParameter Parameter;
         public uint Depth;
         public uint Index;
         public bool IsParameterPack;
@@ -677,10 +677,9 @@ namespace CppSharp.AST
         public TemplateParameterType(TemplateParameterType type)
             : base(type)
         {
-            Parameter = new TemplateParameter
+            Parameter = new TypeTemplateParameter
             {
                 Constraint = type.Parameter.Constraint,
-                IsTypeParameter = type.Parameter.IsTypeParameter,
                 Name = type.Parameter.Name
             };
             Depth = type.Depth;

src/Core/Parser/ASTConverter.cs

@@ -139,6 +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 VisitNonTypeTemplateParameter(NonTypeTemplateParameter decl);
 
         public virtual TRet Visit(Parser.AST.Declaration decl)
         {
@@ -229,6 +231,16 @@ namespace CppSharp
                         var _decl = FunctionTemplate.__CreateInstance(decl.__Instance);
                         return VisitFunctionTemplate(_decl);
                     }
+                case DeclarationKind.TemplateTypeParm:
+                    {
+                        var _decl = TypeTemplateParameter.__CreateInstance(decl.__Instance);
+                        return VisitTemplateParameter(_decl);
+                    }
+                case DeclarationKind.NonTypeTemplateParm:
+                    {
+                        var _decl = NonTypeTemplateParameter.__CreateInstance(decl.__Instance);
+                        return VisitNonTypeTemplateParameter(_decl);
+                    }
             }
 
             throw new ArgumentOutOfRangeException();
@@ -554,7 +566,8 @@ namespace CppSharp
         public override AST.Type VisitTemplateParameter(TemplateParameterType type)
         {
             var _type = new AST.TemplateParameterType();
-            _type.Parameter = DeclConverter.VisitTemplateParameter(type.Parameter);
+            if (type.Parameter != null)
+                _type.Parameter = (AST.TypeTemplateParameter) declConverter.Visit(type.Parameter);
             _type.Depth = type.Depth;
             _type.Index = type.Index;
             _type.IsParameterPack = type.IsParameterPack;
@@ -1426,19 +1439,11 @@ namespace CppSharp
             for (uint i = 0; i < template.ParametersCount; ++i)
             {
                 var param = template.getParameters(i);
-                var _param = VisitTemplateParameter(param);
+                var _param = (AST.TemplateParameter) Visit(param);
                 _template.Parameters.Add(_param);
             }
         }
 
-        public static AST.TemplateParameter VisitTemplateParameter(TemplateParameter param)
-        {
-            var _param = new AST.TemplateParameter();
-            _param.Name = param.Name;
-            _param.IsTypeParameter = param.IsTypeParameter;
-            return _param;
-        }
-
         public override AST.Declaration VisitClassTemplate(ClassTemplate decl)
         {
             var _decl = new AST.ClassTemplate();
@@ -1635,6 +1640,31 @@ namespace CppSharp
                 _macro.Definition = VisitMacroDefinition(macroExpansion.Definition);
             return _macro;
         }
+
+        public override AST.Declaration VisitTemplateParameter(TypeTemplateParameter decl)
+        {
+            var templateParameter = new AST.TypeTemplateParameter();
+            VisitDeclaration(decl, templateParameter);
+            templateParameter.DefaultArgument = typeConverter.VisitQualified(decl.DefaultArgument);
+            templateParameter.Depth = decl.Depth;
+            templateParameter.Index = decl.Index;
+            templateParameter.IsParameterPack = decl.IsParameterPack;
+            return templateParameter;
+        }
+
+        public override AST.Declaration VisitNonTypeTemplateParameter(NonTypeTemplateParameter decl)
+        {
+            var nonTypeTemplateParameter = new AST.NonTypeTemplateParameter();
+            VisitDeclaration(decl, nonTypeTemplateParameter);
+            nonTypeTemplateParameter.DefaultArgument = VisitStatement(decl.DefaultArgument);
+            nonTypeTemplateParameter.Depth = decl.Depth;
+            nonTypeTemplateParameter.Position = decl.Position;
+            nonTypeTemplateParameter.Index = decl.Index;
+            nonTypeTemplateParameter.IsParameterPack = decl.IsParameterPack;
+            nonTypeTemplateParameter.IsPackExpansion = decl.IsPackExpansion;
+            nonTypeTemplateParameter.IsExpandedParameterPack = decl.IsExpandedParameterPack;
+            return nonTypeTemplateParameter;
+        }
     }
 
     public unsafe class CommentConverter : CommentsVisitor<AST.Comment>

src/CppParser/AST.cpp

@@ -85,6 +85,52 @@ DecayedType::DecayedType() : Type(TypeKind::Decayed) {}
 // Template
 Template::Template(DeclarationKind kind) : Declaration(kind) {}
 
+TemplateParameter::TemplateParameter(DeclarationKind kind)
+    : Declaration(kind)
+    , Depth(0)
+    , Index(0)
+    , IsParameterPack(false)
+{
+}
+
+TemplateParameter::~TemplateParameter()
+{
+}
+
+// TemplateParameter
+TypeTemplateParameter::TypeTemplateParameter()
+    : TemplateParameter(DeclarationKind::TemplateTypeParm)
+{
+}
+
+TypeTemplateParameter::TypeTemplateParameter(const TypeTemplateParameter& rhs)
+    : TemplateParameter(rhs.Kind)
+    , DefaultArgument(rhs.DefaultArgument)
+{
+}
+
+TypeTemplateParameter::~TypeTemplateParameter() {}
+
+NonTypeTemplateParameter::NonTypeTemplateParameter()
+    : TemplateParameter(DeclarationKind::NonTypeTemplateParm)
+    , DefaultArgument(0)
+    , Position(0)
+    , IsPackExpansion(false)
+    , IsExpandedParameterPack(false)
+{
+}
+
+NonTypeTemplateParameter::NonTypeTemplateParameter(const NonTypeTemplateParameter& rhs)
+    : TemplateParameter(rhs.Kind)
+    , DefaultArgument(rhs.DefaultArgument)
+    , Position(rhs.Position)
+    , IsPackExpansion(rhs.IsPackExpansion)
+    , IsExpandedParameterPack(rhs.IsExpandedParameterPack)
+{
+}
+
+NonTypeTemplateParameter::~NonTypeTemplateParameter() {}
+
 TemplateArgument::TemplateArgument() : Declaration(0) {}
 
 TemplateSpecializationType::TemplateSpecializationType()
@@ -97,21 +143,7 @@ TemplateSpecializationType::~TemplateSpecializationType() {}
 
 DEF_VECTOR(TemplateSpecializationType, TemplateArgument, Arguments)
 
-// TemplateParameter
-TemplateParameter::TemplateParameter() 
-    : IsTypeParameter(false)
-{
-}
-
-TemplateParameter::TemplateParameter(const TemplateParameter& rhs)
-    : Name(rhs.Name)
-    , IsTypeParameter(rhs.IsTypeParameter)
-{
-}
-
-DEF_STRING(TemplateParameter, Name)
-
-TemplateParameterType::TemplateParameterType() : Type(TypeKind::TemplateParameter) {}
+TemplateParameterType::TemplateParameterType() : Type(TypeKind::TemplateParameter), Parameter(0) {}
 
 TemplateParameterType::~TemplateParameterType() {}
 
@@ -643,7 +675,7 @@ DEF_VECTOR(Class, AccessSpecifierDecl*, Specifiers)
 Template::Template() : Declaration(DeclarationKind::Template),
     TemplatedDecl(0) {}
 
-DEF_VECTOR(Template, TemplateParameter, Parameters)
+DEF_VECTOR(Template, Declaration*, Parameters)
 
 ClassTemplate::ClassTemplate() : Template(DeclarationKind::ClassTemplate) {}
 

src/CppParser/AST.h

@@ -194,27 +194,14 @@ public:
     Type* Desugared;
 };
 
-class CS_API TemplateParameter
-{
-public:
-    TemplateParameter();
-    TemplateParameter(const TemplateParameter&);
-
-    bool operator==(const TemplateParameter& param) const
-    {
-        return Name == param.Name;
-    }
-
-    STRING(Name)
-    bool IsTypeParameter;
-};
+class TypeTemplateParameter;
 
 class CS_API TemplateParameterType : public Type
 {
 public:
-    ~TemplateParameterType();
     DECLARE_TYPE_KIND(TemplateParameter)
-    TemplateParameter Parameter;
+    ~TemplateParameterType();
+    TypeTemplateParameter* Parameter;
     unsigned int Depth;
     unsigned int Index;
     bool IsParameterPack;
@@ -369,6 +356,8 @@ enum class DeclarationKind
     MacroExpansion,
     TranslationUnit,
     Friend,
+    TemplateTypeParm,
+    NonTypeTemplateParm
 };
 
 #define DECLARE_DECL_KIND(klass, kind) \
@@ -759,7 +748,40 @@ public:
     Template(DeclarationKind kind);
     DECLARE_DECL_KIND(Template, Template)
     Declaration* TemplatedDecl;
-    VECTOR(TemplateParameter, Parameters)
+    VECTOR(Declaration*, Parameters)
+};
+
+class CS_API TemplateParameter : public Declaration
+{
+public:
+    TemplateParameter(DeclarationKind kind);
+    ~TemplateParameter();
+    unsigned int Depth;
+    unsigned int Index;
+    bool IsParameterPack;
+};
+
+class CS_API TypeTemplateParameter : public TemplateParameter
+{
+public:
+    TypeTemplateParameter();
+    TypeTemplateParameter(const TypeTemplateParameter&);
+    ~TypeTemplateParameter();
+
+    QualifiedType DefaultArgument;
+};
+
+class CS_API NonTypeTemplateParameter : public TemplateParameter
+{
+public:
+    NonTypeTemplateParameter();
+    NonTypeTemplateParameter(const NonTypeTemplateParameter&);
+    ~NonTypeTemplateParameter();
+
+    Expression* DefaultArgument;
+    unsigned int Position;
+    bool IsPackExpansion;
+    bool IsExpandedParameterPack;
 };
 
 class ClassTemplateSpecialization;

src/CppParser/Bindings/CLI/AST.cpp

@@ -801,88 +801,6 @@ void CppSharp::Parser::AST::TemplateSpecializationType::Desugared::set(CppSharp:
     ((::CppSharp::CppParser::AST::TemplateSpecializationType*)NativePtr)->Desugared = (::CppSharp::CppParser::AST::Type*)value->NativePtr;
 }
 
-CppSharp::Parser::AST::TemplateParameter::TemplateParameter(::CppSharp::CppParser::AST::TemplateParameter* native)
-    : __ownsNativeInstance(false)
-{
-    NativePtr = native;
-}
-
-CppSharp::Parser::AST::TemplateParameter^ CppSharp::Parser::AST::TemplateParameter::__CreateInstance(::System::IntPtr native)
-{
-    return gcnew ::CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*) native.ToPointer());
-}
-
-CppSharp::Parser::AST::TemplateParameter::~TemplateParameter()
-{
-    delete NativePtr;
-}
-
-CppSharp::Parser::AST::TemplateParameter::TemplateParameter()
-{
-    __ownsNativeInstance = true;
-    NativePtr = new ::CppSharp::CppParser::AST::TemplateParameter();
-}
-
-CppSharp::Parser::AST::TemplateParameter::TemplateParameter(CppSharp::Parser::AST::TemplateParameter^ _0)
-{
-    __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::TemplateParameter*)_0->NativePtr;
-    NativePtr = new ::CppSharp::CppParser::AST::TemplateParameter(arg0);
-}
-
-bool CppSharp::Parser::AST::TemplateParameter::operator==(CppSharp::Parser::AST::TemplateParameter^ __op, CppSharp::Parser::AST::TemplateParameter^ param)
-{
-    bool __opNull = ReferenceEquals(__op, nullptr);
-    bool paramNull = ReferenceEquals(param, nullptr);
-    if (__opNull || paramNull)
-        return __opNull && paramNull;
-    auto &arg0 = *(::CppSharp::CppParser::AST::TemplateParameter*)__op->NativePtr;
-    auto &arg1 = *(::CppSharp::CppParser::AST::TemplateParameter*)param->NativePtr;
-    auto __ret = arg0 == arg1;
-    return __ret;
-}
-
-bool CppSharp::Parser::AST::TemplateParameter::Equals(::System::Object^ obj)
-{
-    return this == safe_cast<CppSharp::Parser::AST::TemplateParameter^>(obj);
-}
-
-System::IntPtr CppSharp::Parser::AST::TemplateParameter::__Instance::get()
-{
-    return System::IntPtr(NativePtr);
-}
-
-void CppSharp::Parser::AST::TemplateParameter::__Instance::set(System::IntPtr object)
-{
-    NativePtr = (::CppSharp::CppParser::AST::TemplateParameter*)object.ToPointer();
-}
-
-System::String^ CppSharp::Parser::AST::TemplateParameter::Name::get()
-{
-    auto __ret = ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->getName();
-    if (__ret == nullptr) return nullptr;
-    return (__ret == 0 ? nullptr : clix::marshalString<clix::E_UTF8>(__ret));
-}
-
-void CppSharp::Parser::AST::TemplateParameter::Name::set(System::String^ s)
-{
-    auto _arg0 = clix::marshalString<clix::E_UTF8>(s);
-    auto arg0 = _arg0.c_str();
-    ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->setName(arg0);
-}
-
-bool CppSharp::Parser::AST::TemplateParameter::IsTypeParameter::get()
-{
-    return ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->IsTypeParameter;
-}
-
-void CppSharp::Parser::AST::TemplateParameter::IsTypeParameter::set(bool value)
-{
-    ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->IsTypeParameter = value;
-}
-
 CppSharp::Parser::AST::TemplateParameterType::TemplateParameterType(::CppSharp::CppParser::AST::TemplateParameterType* native)
     : CppSharp::Parser::AST::Type((::CppSharp::CppParser::AST::Type*)native)
 {
@@ -920,14 +838,14 @@ CppSharp::Parser::AST::TemplateParameterType::TemplateParameterType(CppSharp::Pa
     NativePtr = new ::CppSharp::CppParser::AST::TemplateParameterType(arg0);
 }
 
-CppSharp::Parser::AST::TemplateParameter^ CppSharp::Parser::AST::TemplateParameterType::Parameter::get()
+CppSharp::Parser::AST::TypeTemplateParameter^ CppSharp::Parser::AST::TemplateParameterType::Parameter::get()
 {
-    return (&((::CppSharp::CppParser::AST::TemplateParameterType*)NativePtr)->Parameter == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)&((::CppSharp::CppParser::AST::TemplateParameterType*)NativePtr)->Parameter);
+    return (((::CppSharp::CppParser::AST::TemplateParameterType*)NativePtr)->Parameter == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TypeTemplateParameter((::CppSharp::CppParser::AST::TypeTemplateParameter*)((::CppSharp::CppParser::AST::TemplateParameterType*)NativePtr)->Parameter);
 }
 
-void CppSharp::Parser::AST::TemplateParameterType::Parameter::set(CppSharp::Parser::AST::TemplateParameter^ value)
+void CppSharp::Parser::AST::TemplateParameterType::Parameter::set(CppSharp::Parser::AST::TypeTemplateParameter^ value)
 {
-    ((::CppSharp::CppParser::AST::TemplateParameterType*)NativePtr)->Parameter = *(::CppSharp::CppParser::AST::TemplateParameter*)value->NativePtr;
+    ((::CppSharp::CppParser::AST::TemplateParameterType*)NativePtr)->Parameter = (::CppSharp::CppParser::AST::TypeTemplateParameter*)value->NativePtr;
 }
 
 unsigned int CppSharp::Parser::AST::TemplateParameterType::Depth::get()
@@ -3485,18 +3403,18 @@ CppSharp::Parser::AST::Template::Template()
     NativePtr = new ::CppSharp::CppParser::AST::Template();
 }
 
-CppSharp::Parser::AST::TemplateParameter^ CppSharp::Parser::AST::Template::getParameters(unsigned int i)
+CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Template::getParameters(unsigned int i)
 {
     auto __ret = ((::CppSharp::CppParser::AST::Template*)NativePtr)->getParameters(i);
-    auto ____ret = new ::CppSharp::CppParser::AST::TemplateParameter(__ret);
-    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)____ret);
+    if (__ret == nullptr) return nullptr;
+    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)__ret);
 }
 
-void CppSharp::Parser::AST::Template::addParameters(CppSharp::Parser::AST::TemplateParameter^ s)
+void CppSharp::Parser::AST::Template::addParameters(CppSharp::Parser::AST::Declaration^ s)
 {
     if (ReferenceEquals(s, nullptr))
         throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
-    auto &arg0 = *(::CppSharp::CppParser::AST::TemplateParameter*)s->NativePtr;
+    auto arg0 = (::CppSharp::CppParser::AST::Declaration*)s->NativePtr;
     ((::CppSharp::CppParser::AST::Template*)NativePtr)->addParameters(arg0);
 }
 
@@ -3531,6 +3449,198 @@ 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::TemplateParameter::TemplateParameter(::CppSharp::CppParser::AST::TemplateParameter* native)
+    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
+{
+}
+
+CppSharp::Parser::AST::TemplateParameter^ CppSharp::Parser::AST::TemplateParameter::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*) native.ToPointer());
+}
+
+CppSharp::Parser::AST::TemplateParameter::~TemplateParameter()
+{
+    if (NativePtr)
+    {
+        auto __nativePtr = NativePtr;
+        NativePtr = 0;
+        delete (::CppSharp::CppParser::AST::TemplateParameter*) __nativePtr;
+    }
+}
+
+CppSharp::Parser::AST::TemplateParameter::TemplateParameter(CppSharp::Parser::AST::DeclarationKind kind)
+    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
+{
+    __ownsNativeInstance = true;
+    auto arg0 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
+    NativePtr = new ::CppSharp::CppParser::AST::TemplateParameter(arg0);
+}
+
+CppSharp::Parser::AST::TemplateParameter::TemplateParameter(CppSharp::Parser::AST::TemplateParameter^ _0)
+    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)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::TemplateParameter*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::TemplateParameter(arg0);
+}
+
+unsigned int CppSharp::Parser::AST::TemplateParameter::Depth::get()
+{
+    return ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->Depth;
+}
+
+void CppSharp::Parser::AST::TemplateParameter::Depth::set(unsigned int value)
+{
+    ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->Depth = value;
+}
+
+unsigned int CppSharp::Parser::AST::TemplateParameter::Index::get()
+{
+    return ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->Index;
+}
+
+void CppSharp::Parser::AST::TemplateParameter::Index::set(unsigned int value)
+{
+    ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->Index = value;
+}
+
+bool CppSharp::Parser::AST::TemplateParameter::IsParameterPack::get()
+{
+    return ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->IsParameterPack;
+}
+
+void CppSharp::Parser::AST::TemplateParameter::IsParameterPack::set(bool value)
+{
+    ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->IsParameterPack = value;
+}
+
+CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter(::CppSharp::CppParser::AST::TypeTemplateParameter* native)
+    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)native)
+{
+}
+
+CppSharp::Parser::AST::TypeTemplateParameter^ CppSharp::Parser::AST::TypeTemplateParameter::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::AST::TypeTemplateParameter((::CppSharp::CppParser::AST::TypeTemplateParameter*) native.ToPointer());
+}
+
+CppSharp::Parser::AST::TypeTemplateParameter::~TypeTemplateParameter()
+{
+    if (NativePtr)
+    {
+        auto __nativePtr = NativePtr;
+        NativePtr = 0;
+        delete (::CppSharp::CppParser::AST::TypeTemplateParameter*) __nativePtr;
+    }
+}
+
+CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter()
+    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)nullptr)
+{
+    __ownsNativeInstance = true;
+    NativePtr = new ::CppSharp::CppParser::AST::TypeTemplateParameter();
+}
+
+CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter(CppSharp::Parser::AST::TypeTemplateParameter^ _0)
+    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)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::TypeTemplateParameter*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::TypeTemplateParameter(arg0);
+}
+
+CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::TypeTemplateParameter::DefaultArgument::get()
+{
+    return (&((::CppSharp::CppParser::AST::TypeTemplateParameter*)NativePtr)->DefaultArgument == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::QualifiedType((::CppSharp::CppParser::AST::QualifiedType*)&((::CppSharp::CppParser::AST::TypeTemplateParameter*)NativePtr)->DefaultArgument);
+}
+
+void CppSharp::Parser::AST::TypeTemplateParameter::DefaultArgument::set(CppSharp::Parser::AST::QualifiedType^ value)
+{
+    ((::CppSharp::CppParser::AST::TypeTemplateParameter*)NativePtr)->DefaultArgument = *(::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
+}
+
+CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter(::CppSharp::CppParser::AST::NonTypeTemplateParameter* native)
+    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)native)
+{
+}
+
+CppSharp::Parser::AST::NonTypeTemplateParameter^ CppSharp::Parser::AST::NonTypeTemplateParameter::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::AST::NonTypeTemplateParameter((::CppSharp::CppParser::AST::NonTypeTemplateParameter*) native.ToPointer());
+}
+
+CppSharp::Parser::AST::NonTypeTemplateParameter::~NonTypeTemplateParameter()
+{
+    if (NativePtr)
+    {
+        auto __nativePtr = NativePtr;
+        NativePtr = 0;
+        delete (::CppSharp::CppParser::AST::NonTypeTemplateParameter*) __nativePtr;
+    }
+}
+
+CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter()
+    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)nullptr)
+{
+    __ownsNativeInstance = true;
+    NativePtr = new ::CppSharp::CppParser::AST::NonTypeTemplateParameter();
+}
+
+CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter(CppSharp::Parser::AST::NonTypeTemplateParameter^ _0)
+    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)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::NonTypeTemplateParameter*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::NonTypeTemplateParameter(arg0);
+}
+
+CppSharp::Parser::AST::Expression^ CppSharp::Parser::AST::NonTypeTemplateParameter::DefaultArgument::get()
+{
+    return (((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->DefaultArgument == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->DefaultArgument);
+}
+
+void CppSharp::Parser::AST::NonTypeTemplateParameter::DefaultArgument::set(CppSharp::Parser::AST::Expression^ value)
+{
+    ((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->DefaultArgument = (::CppSharp::CppParser::AST::Expression*)value->NativePtr;
+}
+
+unsigned int CppSharp::Parser::AST::NonTypeTemplateParameter::Position::get()
+{
+    return ((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->Position;
+}
+
+void CppSharp::Parser::AST::NonTypeTemplateParameter::Position::set(unsigned int value)
+{
+    ((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->Position = value;
+}
+
+bool CppSharp::Parser::AST::NonTypeTemplateParameter::IsPackExpansion::get()
+{
+    return ((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->IsPackExpansion;
+}
+
+void CppSharp::Parser::AST::NonTypeTemplateParameter::IsPackExpansion::set(bool value)
+{
+    ((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->IsPackExpansion = value;
+}
+
+bool CppSharp::Parser::AST::NonTypeTemplateParameter::IsExpandedParameterPack::get()
+{
+    return ((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->IsExpandedParameterPack;
+}
+
+void CppSharp::Parser::AST::NonTypeTemplateParameter::IsExpandedParameterPack::set(bool value)
+{
+    ((::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->IsExpandedParameterPack = value;
+}
+
 CppSharp::Parser::AST::ClassTemplate::ClassTemplate(::CppSharp::CppParser::AST::ClassTemplate* native)
     : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
 {

src/CppParser/Bindings/CLI/AST.h

@@ -67,6 +67,7 @@ namespace CppSharp
             ref class Method;
             ref class Namespace;
             ref class NativeLibrary;
+            ref class NonTypeTemplateParameter;
             ref class PackExpansionType;
             ref class ParagraphComment;
             ref class ParamCommandComment;
@@ -88,6 +89,7 @@ namespace CppSharp
             ref class TranslationUnit;
             ref class Type;
             ref class TypeQualifiers;
+            ref class TypeTemplateParameter;
             ref class TypedefDecl;
             ref class TypedefType;
             ref class VFTableInfo;
@@ -149,7 +151,9 @@ namespace CppSharp
                 MacroDefinition = 18,
                 MacroExpansion = 19,
                 TranslationUnit = 20,
-                Friend = 21
+                Friend = 21,
+                TemplateTypeParm = 22,
+                NonTypeTemplateParm = 23
             };
 
             public enum struct AccessSpecifier
@@ -772,45 +776,6 @@ namespace CppSharp
                 void clearArguments();
             };
 
-            public ref class TemplateParameter : ICppInstance
-            {
-            public:
-
-                property ::CppSharp::CppParser::AST::TemplateParameter* NativePtr;
-                property System::IntPtr __Instance
-                {
-                    virtual System::IntPtr get();
-                    virtual void set(System::IntPtr instance);
-                }
-
-                TemplateParameter(::CppSharp::CppParser::AST::TemplateParameter* native);
-                static TemplateParameter^ __CreateInstance(::System::IntPtr native);
-                TemplateParameter();
-
-                TemplateParameter(CppSharp::Parser::AST::TemplateParameter^ _0);
-
-                ~TemplateParameter();
-
-                property System::String^ Name
-                {
-                    System::String^ get();
-                    void set(System::String^);
-                }
-
-                property bool IsTypeParameter
-                {
-                    bool get();
-                    void set(bool);
-                }
-
-                static bool operator==(CppSharp::Parser::AST::TemplateParameter^ __op, CppSharp::Parser::AST::TemplateParameter^ param);
-
-                virtual bool Equals(::System::Object^ obj) override;
-
-                protected:
-                bool __ownsNativeInstance;
-            };
-
             public ref class TemplateParameterType : CppSharp::Parser::AST::Type
             {
             public:
@@ -823,10 +788,10 @@ namespace CppSharp
 
                 ~TemplateParameterType();
 
-                property CppSharp::Parser::AST::TemplateParameter^ Parameter
+                property CppSharp::Parser::AST::TypeTemplateParameter^ Parameter
                 {
-                    CppSharp::Parser::AST::TemplateParameter^ get();
-                    void set(CppSharp::Parser::AST::TemplateParameter^);
+                    CppSharp::Parser::AST::TypeTemplateParameter^ get();
+                    void set(CppSharp::Parser::AST::TypeTemplateParameter^);
                 }
 
                 property unsigned int Depth
@@ -2090,13 +2055,100 @@ namespace CppSharp
                     void set(CppSharp::Parser::AST::Declaration^);
                 }
 
-                CppSharp::Parser::AST::TemplateParameter^ getParameters(unsigned int i);
+                CppSharp::Parser::AST::Declaration^ getParameters(unsigned int i);
 
-                void addParameters(CppSharp::Parser::AST::TemplateParameter^ s);
+                void addParameters(CppSharp::Parser::AST::Declaration^ s);
 
                 void clearParameters();
             };
 
+            public ref class TemplateParameter : CppSharp::Parser::AST::Declaration
+            {
+            public:
+
+                TemplateParameter(::CppSharp::CppParser::AST::TemplateParameter* native);
+                static TemplateParameter^ __CreateInstance(::System::IntPtr native);
+                TemplateParameter(CppSharp::Parser::AST::DeclarationKind kind);
+
+                TemplateParameter(CppSharp::Parser::AST::TemplateParameter^ _0);
+
+                ~TemplateParameter();
+
+                property unsigned int Depth
+                {
+                    unsigned int get();
+                    void set(unsigned int);
+                }
+
+                property unsigned int Index
+                {
+                    unsigned int get();
+                    void set(unsigned int);
+                }
+
+                property bool IsParameterPack
+                {
+                    bool get();
+                    void set(bool);
+                }
+            };
+
+            public ref class TypeTemplateParameter : CppSharp::Parser::AST::TemplateParameter
+            {
+            public:
+
+                TypeTemplateParameter(::CppSharp::CppParser::AST::TypeTemplateParameter* native);
+                static TypeTemplateParameter^ __CreateInstance(::System::IntPtr native);
+                TypeTemplateParameter();
+
+                TypeTemplateParameter(CppSharp::Parser::AST::TypeTemplateParameter^ _0);
+
+                ~TypeTemplateParameter();
+
+                property CppSharp::Parser::AST::QualifiedType^ DefaultArgument
+                {
+                    CppSharp::Parser::AST::QualifiedType^ get();
+                    void set(CppSharp::Parser::AST::QualifiedType^);
+                }
+            };
+
+            public ref class NonTypeTemplateParameter : CppSharp::Parser::AST::TemplateParameter
+            {
+            public:
+
+                NonTypeTemplateParameter(::CppSharp::CppParser::AST::NonTypeTemplateParameter* native);
+                static NonTypeTemplateParameter^ __CreateInstance(::System::IntPtr native);
+                NonTypeTemplateParameter();
+
+                NonTypeTemplateParameter(CppSharp::Parser::AST::NonTypeTemplateParameter^ _0);
+
+                ~NonTypeTemplateParameter();
+
+                property CppSharp::Parser::AST::Expression^ DefaultArgument
+                {
+                    CppSharp::Parser::AST::Expression^ get();
+                    void set(CppSharp::Parser::AST::Expression^);
+                }
+
+                property unsigned int Position
+                {
+                    unsigned int get();
+                    void set(unsigned int);
+                }
+
+                property bool IsPackExpansion
+                {
+                    bool get();
+                    void set(bool);
+                }
+
+                property bool IsExpandedParameterPack
+                {
+                    bool get();
+                    void set(bool);
+                }
+            };
+
             public ref class ClassTemplate : CppSharp::Parser::AST::Template
             {
             public:

src/CppParser/Parser.cpp

@@ -29,7 +29,6 @@
 #include <clang/AST/ASTContext.h>
 #include <clang/AST/Comment.h>
 #include <clang/AST/DeclFriend.h>
-#include <clang/AST/DeclTemplate.h>
 #include <clang/AST/ExprCXX.h>
 #include <clang/Lex/DirectoryLookup.h>
 #include <clang/Lex/HeaderSearch.h>
@@ -957,41 +956,14 @@ Parser::WalkClassTemplatePartialSpecialization(clang::ClassTemplatePartialSpecia
 
 //-----------------------------------//
 
-CppSharp::CppParser::TemplateParameter
-WalkTemplateParameter(const clang::NamedDecl* D)
+std::vector<Declaration*> Parser::WalkTemplateParameterList(const clang::TemplateParameterList* TPL)
 {
-    using namespace clang;
-
-    auto TP = CppSharp::CppParser::TemplateParameter();
-    if (D == nullptr)
-        return TP;
-
-    TP.Name = GetDeclName(D);
-    switch (D->getKind())
-    {
-    case Decl::TemplateTypeParm:
-    {
-        auto TTPD = cast<TemplateTypeParmDecl>(D);
-        TP.IsTypeParameter = true;
-        break;
-    }
-    default:
-        break;
-    }
-    return TP;
-}
-
-//-----------------------------------//
-
-static std::vector<CppSharp::CppParser::TemplateParameter>
-WalkTemplateParameterList(const clang::TemplateParameterList* TPL)
-{
-    auto params = std::vector<CppSharp::CppParser::TemplateParameter>();
+    auto params = std::vector<CppSharp::CppParser::Declaration*>();
 
     for (auto it = TPL->begin(); it != TPL->end(); ++it)
     {
         auto ND = *it;
-        auto TP = WalkTemplateParameter(ND);
+        auto TP = WalkDeclaration(ND, /*IgnoreSystemDecls=*/false);
         params.push_back(TP);
     }
 
@@ -1031,6 +1003,41 @@ ClassTemplate* Parser::WalkClassTemplate(clang::ClassTemplateDecl* TD)
 
 //-----------------------------------//
 
+TypeTemplateParameter* Parser::WalkTypeTemplateParameter(clang::TemplateTypeParmDecl* TTPD)
+{
+    using namespace clang;
+
+    auto TP = new CppSharp::CppParser::TypeTemplateParameter();
+    TP->Name = GetDeclName(TTPD);
+    HandleDeclaration(TTPD, TP);
+    if (TTPD->hasDefaultArgument())
+        TP->DefaultArgument = GetQualifiedType(
+            TTPD->getDefaultArgument(), WalkType(TTPD->getDefaultArgument()));
+    TP->Depth = TTPD->getDepth();
+    TP->Index = TTPD->getIndex();
+    TP->IsParameterPack = TTPD->isParameterPack();
+    return TP;
+}
+
+//-----------------------------------//
+
+NonTypeTemplateParameter* Parser::WalkNonTypeTemplateParameter(clang::NonTypeTemplateParmDecl* NTTPD)
+{
+    using namespace clang;
+
+    auto NTP = new CppSharp::CppParser::NonTypeTemplateParameter();
+    NTP->Name = GetDeclName(NTTPD);
+    HandleDeclaration(NTTPD, NTP);
+    if (NTTPD->hasDefaultArgument())
+        NTP->DefaultArgument = WalkExpression(NTTPD->getDefaultArgument());
+    NTP->Depth = NTTPD->getDepth();
+    NTP->Index = NTTPD->getIndex();
+    NTP->IsParameterPack = NTTPD->isParameterPack();
+    return NTP;
+}
+
+//-----------------------------------//
+
 std::vector<CppSharp::CppParser::TemplateArgument>
 Parser::WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL,
     clang::TemplateSpecializationTypeLoc* TSTL)
@@ -1977,7 +1984,7 @@ Type* Parser::WalkType(clang::QualType QualType, clang::TypeLoc* TL,
         auto TPT = new CppSharp::CppParser::TemplateParameterType();
 
         if (auto Ident = TP->getIdentifier())
-            TPT->Parameter.Name = Ident->getName();
+            TPT->Parameter->Name = Ident->getName();
 
         TypeLoc UTL, ETL, ITL, Next;
 
@@ -2005,7 +2012,7 @@ Type* Parser::WalkType(clang::QualType QualType, clang::TypeLoc* TL,
             assert(TL->getTypeLocClass() == TypeLoc::TemplateTypeParm);
             auto TTTL = TL->getAs<TemplateTypeParmTypeLoc>();
 
-            TPT->Parameter = WalkTemplateParameter(TTTL.getDecl());
+            TPT->Parameter = WalkTypeTemplateParameter(TTTL.getDecl());
         }
         TPT->Depth = TP->getDepth();
         TPT->Index = TP->getIndex();
@@ -2734,6 +2741,7 @@ AST::Expression* Parser::WalkExpression(clang::Expr* Expr)
     if (Expr->getStmtClass() != Stmt::CharacterLiteralClass &&
         Expr->getStmtClass() != Stmt::CXXBoolLiteralExprClass &&
         Expr->getStmtClass() != Stmt::UnaryExprOrTypeTraitExprClass &&
+        !Expr->isValueDependent() &&
         Expr->EvaluateAsInt(integer, C->getASTContext()))
         return new AST::Expression(integer.toString(10));
     return new AST::Expression(GetStringFromStatement(Expr));
@@ -3042,6 +3050,18 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
         Decl = WalkFriend(FD);
         break;
     }
+    case Decl::TemplateTypeParm:
+    {
+        auto TTPD = cast<TemplateTypeParmDecl>(D);
+        Decl = WalkTypeTemplateParameter(TTPD);
+        break;
+    }
+    case Decl::NonTypeTemplateParm:
+    {
+        auto NTTPD = cast<NonTypeTemplateParmDecl>(D);
+        Decl = WalkNonTypeTemplateParameter(NTTPD);
+        break;
+    }
     // Ignore these declarations since they must have been declared in
     // a class already.
     case Decl::CXXDestructor:

src/CppParser/Parser.h

@@ -12,6 +12,7 @@
 #include <llvm/Object/SymbolicFile.h>
 
 #include <clang/AST/ASTFwd.h>
+#include <clang/AST/DeclTemplate.h>
 #include <clang/AST/Type.h>
 #include <clang/Basic/TargetInfo.h>
 #include <clang/Frontend/CompilerInstance.h>
@@ -81,8 +82,6 @@ protected:
     WalkClassTemplatePartialSpecialization(clang::ClassTemplatePartialSpecializationDecl* CTS);
     Method* WalkMethodCXX(clang::CXXMethodDecl* MD);
     Field* WalkFieldCXX(clang::FieldDecl* FD, Class* Class);
-    ClassTemplate* WalkClassTemplate(clang::ClassTemplateDecl* TD);
-    FunctionTemplate* WalkFunctionTemplate(clang::FunctionTemplateDecl* TD);
     FunctionTemplateSpecialization* WalkFunctionTemplateSpec(clang::FunctionTemplateSpecializationInfo* FTS, Function* Function);
     Variable* WalkVariable(clang::VarDecl* VD);
     Friend* WalkFriend(clang::FriendDecl* FD);
@@ -90,6 +89,11 @@ protected:
     Type* WalkType(clang::QualType QualType, clang::TypeLoc* TL = 0,
       bool DesugarType = false);
     TemplateArgument WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateArgumentLoc* ArgLoc);
+    TypeTemplateParameter* WalkTypeTemplateParameter(clang::TemplateTypeParmDecl* TTPD);
+    NonTypeTemplateParameter* WalkNonTypeTemplateParameter(clang::NonTypeTemplateParmDecl* TTPD);
+    std::vector<Declaration*> WalkTemplateParameterList(const clang::TemplateParameterList* TPL);
+    ClassTemplate* WalkClassTemplate(clang::ClassTemplateDecl* TD);
+    FunctionTemplate* WalkFunctionTemplate(clang::FunctionTemplateDecl* TD);
     std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, clang::TemplateSpecializationTypeLoc* TSTL);
     std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, const clang::ASTTemplateArgumentListInfo* TSTL);
     void WalkVTable(clang::CXXRecordDecl* RD, Class* C);

src/Generator.Tests/AST/TestAST.cs

@@ -4,6 +4,7 @@ using CppSharp.AST;
 using CppSharp.AST.Extensions;
 using NUnit.Framework;
 using CppSharp.Generators.CSharp;
+using System;
 
 namespace CppSharp.Generator.Tests.AST
 {
@@ -149,6 +150,16 @@ namespace CppSharp.Generator.Tests.AST
             {
                 throw new System.NotImplementedException();
             }
+
+            public bool VisitTemplateParameter(TypeTemplateParameter templateParameter)
+            {
+                throw new NotImplementedException();
+            }
+
+            public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+            {
+                throw new NotImplementedException();
+            }
         }
         #endregion
 
@@ -184,8 +195,6 @@ namespace CppSharp.Generator.Tests.AST
             Assert.AreEqual(2, twoParamMethodTemplate.Parameters.Count);
             Assert.AreEqual("T", twoParamMethodTemplate.Parameters[0].Name);
             Assert.AreEqual("S", twoParamMethodTemplate.Parameters[1].Name);
-            Assert.IsTrue(twoParamMethodTemplate.Parameters[0].IsTypeParameter);
-            Assert.IsTrue(twoParamMethodTemplate.Parameters[1].IsTypeParameter);
             var twoParamMethod = twoParamMethodTemplate.TemplatedFunction as Method;
             Assert.IsNotNull(twoParamMethod);
             Assert.IsInstanceOf<TemplateParameterType>(twoParamMethod.Parameters[0].Type);

src/Generator/Generators/CLI/CLIHeadersTemplate.cs

@@ -347,7 +347,7 @@ namespace CppSharp.Generators.CLI
 
                 // Process the generic type constraints
                 var constraints = new List<string>();
-                foreach (var param in template.Parameters)
+                foreach (var param in template.Parameters.OfType<TypeTemplateParameter>())
                 {
                     if (string.IsNullOrWhiteSpace(param.Constraint))
                         continue;

src/Generator/Generators/CLI/CLITypePrinter.cs

@@ -429,5 +429,15 @@ namespace CppSharp.Generators.CLI
         {
             return type.Visit(this);
         }
+
+        public string VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        {
+            return templateParameter.Name;
+        }
+
+        public string VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        {
+            return nonTypeTemplateParameter.Name;
+        }
     }
 }

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -702,6 +702,16 @@ namespace CppSharp.Generators.CSharp
         {
             return type.Visit(this).Type;
         }
+
+        public CSharpTypePrinterResult VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        {
+            return templateParameter.Name;
+        }
+
+        public CSharpTypePrinterResult VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        {
+            return nonTypeTemplateParameter.Name;
+        }
     }
 
     public static class CSharpTypePrinterExtensions

src/Generator/Passes/CheckMacrosPass.cs

@@ -203,40 +203,34 @@ namespace CppSharp.Passes
 
         public override bool VisitClassTemplateDecl(ClassTemplate template)
         {
-            var expansions = template.PreprocessedEntities.OfType<MacroExpansion>();
-
-            var expansion = expansions.FirstOrDefault(e => e.Text.StartsWith(Prefix + "_CONSTRAINT"));
-            if (expansion != null)
-            {
-                var args = GetArguments(expansion.Text);
-                for (var i = 0; i < template.Parameters.Count && i < args.Length; ++i)
-                {
-                    var param = template.Parameters[i];
-                    param.Constraint = args[i];
-                    template.Parameters[i] = param;
-                }
-            }
+            CheckForTemplateConstraints(template);
 
             return base.VisitClassTemplateDecl(template);
         }
 
         public override bool VisitFunctionTemplateDecl(FunctionTemplate template)
+        {
+            CheckForTemplateConstraints(template);
+
+            return base.VisitFunctionTemplateDecl(template);
+        }
+
+        private void CheckForTemplateConstraints(Template template)
         {
             var expansions = template.PreprocessedEntities.OfType<MacroExpansion>();
 
-            var expansion = expansions.FirstOrDefault(e => e.Text.StartsWith(Prefix + "_CONSTRAINT"));
+            var expansion = expansions.FirstOrDefault(
+                e => e.Text.StartsWith(Prefix + "_CONSTRAINT", StringComparison.Ordinal));
             if (expansion != null)
             {
                 var args = GetArguments(expansion.Text);
                 for (var i = 0; i < template.Parameters.Count && i < args.Length; ++i)
                 {
-                    var param = template.Parameters[i];
-                    param.Constraint = args[i];
-                    template.Parameters[i] = param;
+                    var templateParam = template.Parameters[i] as TypeTemplateParameter;
+                    if (templateParam != null)
+                        templateParam.Constraint = args[i];
                 }
             }
-
-            return base.VisitFunctionTemplateDecl(template);
         }
 
         private static string[] GetArguments(string str)

src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs

@@ -242,6 +242,16 @@ namespace CppSharp.Passes
             return false;
         }
 
+        public bool VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        {
+            return false;
+        }
+
+        public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        {
+            return false;
+        }
+
         #endregion
     }
 

src/Generator/Types/CppTypePrinter.cs

@@ -342,5 +342,23 @@ namespace CppSharp.Types
         {
             return type.Visit(this);
         }
+
+        public string VisitTemplateParameter(TypeTemplateParameter templateParameter)
+        {
+            if (templateParameter.DefaultArgument.Type == null)
+                return templateParameter.Name;
+
+            return string.Format("{0} = {1}", templateParameter.Name,
+                templateParameter.DefaultArgument.Visit(this));
+        }
+
+        public string VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter)
+        {
+            if (nonTypeTemplateParameter.DefaultArgument == null)
+                return nonTypeTemplateParameter.Name;
+
+            return string.Format("{0} = {1}",  nonTypeTemplateParameter.Name,
+                nonTypeTemplateParameter.DefaultArgument.String);
+        }
     }
 }