Ensured template arguments of specialised functions are read.

src/CppParser/Parser.cpp

@@ -1298,9 +1298,17 @@ Parser::WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL,
     for (size_t i = 0, e = TAL->size(); i < e; i++)
     {
         auto TA = TAL->get(i);
-        auto ArgLoc = TALI->operator[](i);
-        auto TP = WalkTemplateArgument(TA, &ArgLoc);
-        params.push_back(TP);
+        if (TALI)
+        {
+            auto ArgLoc = TALI->operator[](i);
+            auto TP = WalkTemplateArgument(TA, &ArgLoc);
+            params.push_back(TP);
+        }
+        else
+        {
+            auto TP = WalkTemplateArgument(TA, 0);
+            params.push_back(TP);
+        }
     }
 
     return params;
@@ -1434,10 +1442,6 @@ Parser::WalkFunctionTemplateSpec(clang::FunctionTemplateSpecializationInfo* FTSI
     auto FTS = new CppSharp::CppParser::FunctionTemplateSpecialization();
     FTS->specializationKind = WalkTemplateSpecializationKind(FTSI->getTemplateSpecializationKind());
     FTS->specializedFunction = Function;
-    // HACK: walking template arguments crashes when generating the parser bindings for OS X
-    // so let's disable it for function templates which we do not support yet anyway 
-    //if (auto TALI = FTSI->TemplateArgumentsAsWritten)
-    //    FTS->Arguments = WalkTemplateArgumentList(FTSI->TemplateArguments, TALI);
     FTS->_template = WalkFunctionTemplate(FTSI->getTemplate());
     FTS->_template->Specializations.push_back(FTS);
     if (auto TSA = FTSI->TemplateArguments)
@@ -1447,8 +1451,11 @@ Parser::WalkFunctionTemplateSpec(clang::FunctionTemplateSpecializationInfo* FTSI
             if (TSA->size() == TSAW->NumTemplateArgs)
             {
                 FTS->Arguments = WalkTemplateArgumentList(TSA, TSAW);
+                return FTS;
             }
         }
+        FTS->Arguments = WalkTemplateArgumentList(TSA,
+            (const clang::ASTTemplateArgumentListInfo*) 0);
     }
 
     return FTS;

src/CppParser/ParserGen/ParserGen.cs

@@ -39,7 +39,7 @@ namespace CppSharp
                 var path = Path.Combine(directory.FullName, dir);
 
                 if (Directory.Exists(path) &&
-                    Directory.Exists(Path.Combine(directory.FullName, "patches")))
+                    Directory.Exists(Path.Combine(directory.FullName, "deps")))
                     return path;
 
                 directory = directory.Parent;

src/Generator.Tests/AST/TestAST.cs

@@ -451,5 +451,16 @@ namespace CppSharp.Generator.Tests.AST
             Assert.That(regularFunctionType.ExceptionSpecType,
                 Is.EqualTo(ExceptionSpecType.None));
         }
+
+        [Test]
+        public void TestFunctionSpecializationInfo()
+        {
+            var functionWithSpecInfo = AstContext.FindFunction(
+                "functionWithSpecInfo").First(f => !f.IsDependent);
+            var @float = new QualifiedType(new BuiltinType(PrimitiveType.Float));
+            Assert.That(functionWithSpecInfo.SpecializationInfo.Arguments.Count, Is.EqualTo(2));
+            foreach (var arg in functionWithSpecInfo.SpecializationInfo.Arguments)
+                Assert.That(arg.Type, Is.EqualTo(@float));
+        }
     }
 }

tests/Native/AST.h

@@ -158,3 +158,9 @@ typedef ForwardedTemplate<long> l;
 template class TestSpecializationArguments<const TestASTEnumItemByName>;
 
 constexpr void constExprNoExcept() noexcept;
+
+template <typename T1, typename T2>
+bool functionWithSpecInfo(const T1& t11, const T1& t12, const T2& t2);
+
+template<>
+bool functionWithSpecInfo(const float& t11, const float& t12, const float& t2);